wollf-sft

The supervised fine-tuning data behind the wollf models: Qwen3.6-27B adapted by QLoRA into a model that writes and reasons about wolf, a new compiled systems language. The release config is the exact file wollf-v7sf3 trained on. This datasheet follows Datasheets for Datasets (Gebru et al.). It began as an end-to-end audit of the corpora (2026-09-15) and has been extended with each corpus since. Every number in it is printed by one of the project's audit scripts into a table, kept privately, so any of them can be re-derived.

Reading this datasheet

The datasheet names the machines the work ran on by their hardware. The records behind its figures (logs, tables, graded files) are kept privately with the project, so the datasheet does not cite them. The older generation-time card is kept privately too; where the two disagree, this datasheet is the audited statement.

name	what it is
the 3090 Ti workstation	the project's main workstation. NixOS; Intel Core i7-12700KF (20 threads); 46 GiB RAM; one NVIDIA RTX 3090 Ti, 24 GB. It serves models under llama.cpp (for grading, and for the base's own answers in the self-replay rows) and holds the files of record.
the 4090 workstation	a second workstation. CachyOS Linux; Intel Core i9-11900K (16 threads); 31 GiB RAM; one NVIDIA RTX 4090, 24 GB. It runs the compilers and interpreters that verify rows (gcc, node, python, under bwrap) and the wolf toolchain.
the training node	the rented GPU a given model trained on. v7sf3 and v7sf trained on one NVIDIA L40S, 48 GB (DigitalOcean gpu-l40sx1-48gb, Toronto).

The release config

The release config is corpus-v7-sr36-form, the training mix of the model of record (wollf-v7sf3), byte for byte: release/wollf-mixed.jsonl, 5,190 rows, 14,054,390 B, sha256 bb542fdf98682648821940d2892a977ec00a1023ba66d877a349725aa92435a3. The model card's data sha is this sha. The release build copied corpus-v7-sr36-form/wollf-mixed.jsonl into a release directory on the 3090 Ti workstation (2026-09-30; read twice there: bb542fdf…, 14,054,390 B) and wrote its manifest build-report.json beside it (sha256 6be90881908d8a4aa388926b928941e07eec5c2d7f1bb449ba976ca6f7345b75, committed to the project's audit tables): "release": true, output.sha256, one split (train: 5,190), 0 rows naming any held-out item id (188 ids, every version of the sealed heldout, which lives in a private repository), 0 Magicoder rows, and three attribution entries: wolffe-lang (the Training Data Permission, 39d16667…), CodeAlpaca 20K (release_rule.CODEALPACA_ATTRIBUTION verbatim) and glaive-code-assistant.

the release mix by part (read from each row's meta)	rows	of them answered by a model's own verified output
wolf: teachers qwen3-coder:30b 1,100, Qwen3.6-35B-A3B 1,025, GLM-4.7-Flash 327	2,452	—
general: glaive-code-assistant (Apache-2.0)	1,869	158 (the base's)
general: CodeAlpaca-20k (CC BY 4.0)	444	140 (the base's)
general: wollf-node-js (this project, Apache-2.0; teacher Qwen3.6-35B-A3B)	264	30 (the base's)
general: wollf-answer-form (this project, CC BY 4.0)	161	161 (wollf-v7sr's)

Checks on the staged file:

• release_rule.py, as the release checklist runs it: PASS, exit 0.
• contamination.py against the instrument's twelve item sets (13,965 texts): 0 exact, 0 near, 7 partial on MBPP+ (equal to the training corpus's table).
• seal_heldout.py --heldout v3.1 guard: 5,190 rows against 512 benchmark texts, 0 collisions.

Re-read on 2026-10-14, on the file staged for upload (the same inode as the release build's): sha256 bb542fdf…; seal_heldout.py guard 0 collisions against heldout-v3.1 and against heldout-v3.2, the instrument since 2026-10-07; the row guard GREEN: 409 row–item pairs over 353 rows, 409 accepted, 0 new, 0 grown; release_rule.py PASS. A scan of every row for every held-out id (201 ids, every version) finds none.

The contamination statement for the release (the model card carries the same one):

Measured on the released file (sha256 bb542fdf…, which is also the training mix) with an exact 13-gram token index (containment) and the sealed guard (12-character shingles, Jaccard ≥ 0.5). Against the sealed heldout (512 benchmark texts; v3.1 and v3.2) and the twelve general suites the card reports (HumanEval+, MBPP+, MultiPL-E js/cpp, IFEval, IFBench-mt, GSM8K, MMLU-Pro, BBH, DROP, TruthfulQA MC1, BFCL-AST; 13,965 texts): 0 exact and 0 near hits; 7 partial (≥ 0.2) hits on MBPP+, listed in the audit. The sealed guard finds 0 collisions.

Rows that share text with held-out items. The whole-text measures above do not see a row that does a held-out item's task in other words. Read row by row against every held-out item after training (one reading for the wolf leg, one for the general leg), 45 of this file's 5,190 rows carry a held-out item's solution in substance: 24 wolf rows on four items (wh-004 19, wh-003 2, wh-009 2, and the diagnose item wh-104 1), 14 general rows on nine items of heldout-v3.2 (gh-js-17 5, gh-js-64 2, and one each on gh-c-16, gh-js-23, gh-js-65, gh-js-71, gh-js-74, gh-py-02, gh-py-24), and 7 general rows on six C items that heldout-v3.2 had already replaced (gh-c-15 2; gh-c-01, gh-c-03, gh-c-04, gh-c-07, gh-c-25 1 each). The other 308 rows at the guard's threshold share idiom of the language or a common public source with an item, or were left undecided by their reader. What was done: the 13 live items are tagged corpus-twin and every clean score leaves them out; the six replaced C items were already out of the instrument; the 24 wolf rows are dropped from the next corpus (corpus-v8) but stay in this file, because it is the file the released model trained on; three answer-form specifications are retired from future plans; and a row guard now refuses any mix that adds a row–item pair beyond the 409 characterised here. A retrain without the 24 wolf rows (three seeds) still passed all four of their items on every seed, so those rows are not what passes them; the general rows were not tested that way. Which rows they are is recorded with the items, in the private repository, and not here: a row id beside an item id would point at the item.

The corpora, at a glance

The release mix is the last of a line of corpora. The earlier ones are described here because the models they trained are the comparisons on the model card. Only the release mix is distributed.

corpus	file (training node)	sha256	rows	trained
v2 (model of record until 2026-09-26)	wollf-v2/wollf-mixed.jsonl	afdecebefaa3f1e4deee276449f2a9e737fb8a63b3392f9f0999046a2c966d84	5,160	wollf-v2, v2h, v2p, v2pp (configs stamping afdecebe…)
v4	wollf-v4/wollf-mixed.jsonl	dfaef2e910710c6798a40758c40d7be8d4f96c18bac38fb9b1c00596f1fd5255	5,160	wollf-v4, v4k, v4p, v4r, v4r3, v4rh, v4-q38 (configs stamping dfaef2e9…)
rft-v1	rft-v1/wollf-mixed.jsonl	84fc81295ee68a1514ba92eb0f6106ff3e6f035e857407240b186ce586a6de39	5,294	wollf-v5
v6 (proposed, untrained)	corpus-v6/wollf-mixed.jsonl	12d477f4e2dd0de1d3bfe81262dbed0dfa4184ba92202a856dced72683066c18	5,029	—
v7 (proposed, untrained)	corpus-v7/wollf-mixed.jsonl	b5ef6256e95621d04849b34a25b2dc161090c047521fdecf691427ef45e7765c	5,029	—
v7-sr36 (the candidate)	corpus-v7-sr36/wollf-mixed.jsonl	59fe5ddaa2bb3b9e0db87eb934fbbc3b618d8ec5cc521d937a8dd3516453eefe	5,029	wollf-v7sr, wollf-v7sr3 (configs stamping 59fe5dda…)
v7-sr36-inc (proposed, untrained)	corpus-v7-sr36-inc/wollf-mixed.jsonl	701c7501b97658a039f1cb1998e86cf1c441d3b25d29f9f9a4ec12773508b461	5,029	—
v7-sr36-form (the corpus of record from 2026-09-26: wollf-v7sf3)	corpus-v7-sr36-form/wollf-mixed.jsonl	bb542fdf98682648821940d2892a977ec00a1023ba66d877a349725aa92435a3	5,190	wollf-v7sf, wollf-v7sf3 (configs stamping bb542fdf…)
v7-sr36-form-release (this dataset's release config)	corpus-v7-sr36-form-release/wollf-mixed.jsonl	bb542fdf98682648821940d2892a977ec00a1023ba66d877a349725aa92435a3 (the same bytes)	5,190	— (it is v7sf3's training mix)

Each sha was read twice on the 3090 Ti workstation. v2's also equals the sha stamped at launch in v2's run report, in v2h's launch assert and in two later guard records, so the file on disk is byte-identical to the file v2 was launched on. The 4090 workstation's copy is identical as well. That machine's memory was later found to corrupt large reads, and the launch-time stamp was computed there, but the on-disk file matches it.

The lineage is exact. v4 = v2 with 265 drawn general rows replaced by 265 node-verified javascript rows (4,895 shared rows byte-equal, re-interleaved). rft-v1 = v4 plus 134 three-way-verified wolf rows (all 5,160 rows byte-equal). v6 = v4 minus 131 rows, in v4's order. v7 = v6 with the general half rebuilt and the wolf leg byte-identical (sha 39a3d2e6… in both): 1,141 general rows out (1,017 Magicoder under the release rule, 124 that do not parse or compile standalone), 1,141 drawn from the same normalized pool into the slots they vacated, 194 repaired exactly (192 fenced, 2 given the include the compiler named), and 20 header-not-found rows kept and recorded under the verifying-host rule (below). Row count, leg sizes, wolf fraction and row positions are unchanged. v7 is the first mix with zero Magicoder rows, and so the first that the release rule does not refuse.

corpus-v7-sr36: corpus-v7 with the base's own answers in place (2026-09-22)

v7-sr36 = v7 with 328 general rows replaced in place by the 3.6 base's own verified answers: the gated self-replay rows for q36 (674 verdicts, 334 kept; verified on the 4090 workstation 2026-09-19 under bwrap by python 3.14.6, gcc 16.2.1, node v26.8.1). Built by self_replay.py build-mix --restore-mix (the v7 layout); kept on the 3090 Ti workstation, sha read twice on the 4090 workstation and twice on the 3090 Ti workstation, mix-report.json beside it. Row count, every position and every leg are unchanged, and the wolf leg's 2,452 lines are byte-identical to v7's (the first build re-serialized 543 carried rows and was rebuilt: a carried row is now written as v7's own line). So v7-sr36 against v7 is one variable: 328 general rows now carry the base's own working instead of an upstream answer. The reasoning: the base's derivation is what training removes, so replaying it is the one general source that cannot teach terseness.

how the 334 kept answers entered	rows
in place: the v6 row survived into v7 with the same prompt	164
into a slot v7 had refilled from the pool (the fill record in meta, Magicoder); the kept fill candidate replaces v7's refill	153
restored: the base answered a v6 prompt whose upstream answer v7 dropped (10 does-not-parse, 1 does-not-compile); the v6 row returns with the base's verified answer	11
carried, never duplicated: the fill's pool row (or prompt) was already in v7 as v7's own refill (5 slots)	0 (5 carried)
excluded: general.glaive-code-assistant.015494, because the base's answer near-duplicates HumanEval/19's canonical solution (containment 0.557, contamination.py); v7's refill stays	0 (1 carried)

By verifier level: python exec 215, javascript exec 64, javascript tests 30 (the wollf-node-js node cases), c exec 19, c compile 1. Median answer length on the 328 replaced rows: 1,249 → 385 characters (the base answers the harness's own system line, max_tokens 1,600, temperature 0); the general half's median moves 1,277 → 1,221. Contamination against the instrument's twelve item sets: 0 exact, 0 near, 7 partial on MBPP+, the same 7 v7 carries. Release rule: 0 Magicoder rows (a refill's fill record in meta names, under replaced, the row it replaced, which the scan now reads as provenance, not content). Ids: a replaced row is <id>.sr-q36; meta.self_replay names the base model, the sample, its verifier level and the answer's sha; a refill replacement also names fills_slot and replaces.

corpus-v7-sr36-inc: the c-include dose, as far as the licensed pool allows (2026-09-24)

v7-sr36-inc = v7-sr36 with 28 general rows replaced in place by the 3.6 base's own answers to licensed pool prompts, each kept only because it compiles standalone on the verifying host and carries an #include. The c-include class goes 97 → 125 (v4 carried 223). Row count, every row position, every leg, the wolf leg and every untouched general row are byte-identical to v7-sr36's own lines; the general half is the one variable, as it was for v7 and v7-sr36. All 28 land in slots a Magicoder C row vacated (the placement record's slot_lang == "c" for all 28), and a restored row never displaces a C row, so the C leg only grows: 101 → 129.

The dose could not be restored to v4's 223, and the reason is the data rather than the method. 104 of the 127 c-include rows that left at v7 are Magicoder, which the release rule refuses, prompt included, so they cannot be re-answered either. Of the 132 licensed pool rows whose own answer is C and which are in no mix, exactly one compiles standalone and carries an #include. The base's own answers were generated for every C-facing prompt the pool still holds (285 prompts, 407 answers over three samples) for 34 kept, 28 in the class. There is no further licensed supply: a second pass over the pool for prompts that ask for C and name no other language returns 0 rows, and the mix's own rows return 1.

the restored 28
verifier level	exec 21 (has main, compiles, links, runs to exit 0), compile 7 (function-only, compiles alone with -Werror=implicit-function-declaration -Werror=implicit-int)
sample	temperature 0: 27; temperature 0.6: 1
source	CodeAlpaca 25, glaive-code-assistant 3
carrying an #include inside the C fence	28 of 28
headers taught	stdio.h 24, stdlib.h 6, string.h 6, stdbool.h 2, ctype.h 1, stddef.h 1
explained (prose outside the fence or comments inside it)	15 of 28
displaced	28 v7 pool refills whose own lang_guess is python; no meta.self_replay row, no replay row of any class and no wollf-node-js row is touched

Built by include_dose.py select / build, with self_replay.py gen (the 3090 Ti workstation, the 3.6 base Qwen_Qwen3.6-27B-Q6_K_L.gguf sha 95c61f9a… served alone on :9309 under llama.cpp 9842) and verify (the 4090 workstation: gcc 16.2.1 20260810, node v26.8.1, python 3.14.6, bwrap, the host the verifying-host table declares). Standalone re-check of the built file: 2,129 cases, 2,117 ok, 12 header-not-found (v7-sr36's own 12), and all 30 cases of the 28 restored rows ok. Contamination against the instrument's twelve item sets: 0 exact, 0 near, 7 partial on MBPP+, the same 7 v7 and v7-sr36 carry. seal_heldout.py --heldout v3.1 guard: 0 collisions. 0 Magicoder rows. Ids: a restored row is <pool_id>.inc-q36; meta.self_replay names the base model, the sample, the verifier level and the answer's sha, and a placement record in meta names the slot, its original language and the v7 fill it replaces.

corpus-v7-sr36-form: the standalone-translation-unit form, taught as rows (2026-09-24)

v7-sr36-form = v7-sr36 + 161 rows appended. corpus-v7-sr36's 5,029 rows in their own order, every line byte-identical (the wolf leg's 2,452 lines included), then 161 general rows appended after index 5,028, so against v7-sr36 the one variable is those rows (and, as every append does, the step each row trains at: as self_replay.py records, a change in n puts every row at a different training step whatever its file position). Kept on the 3090 Ti workstation, sha read twice on the 4090 workstation and twice on the 3090 Ti workstation, mix-report.json and shas.txt beside it.

What a row is: an earlier reading found that the corpus-v7 candidate misses heldout-v3.1's C bar on both seeds because its answers to Write a C function `<sig>` … No main. Return only the code. omit their #includes. A follow-up found that the includes appear when one sentence asks for a standalone translation unit (5 of 6 items on both seeds, control 0 of 6), so the defect is one of answer form under that instruction. Each row here is the user turn in exactly that instruction shape on a function this round specified (167 specifications; 147 in the No main. Return only the code. form, 20 in the Include any headers you need. Write ONLY the function (and includes) — no main. form); the assistant turn is wollf-v7sr's own answer to that prompt plus the follow-up's sentence (Return a standalone translation unit: include every header the code needs so it compiles on its own.), generated single-card on the 3090 Ti workstation at the heldout's protocol (the harness system line, sample 0 at temperature 0, samples 1–2 at 0.6/0.95, max_tokens 1,600, thinking off, self_replay.py gen's seed rule), and kept only if it compiles alone as a translation unit with -Werror=implicit-function-declaration -Werror=implicit-int on the verifying host (the 4090 workstation: gcc 16.2.1 20260810, bwrap) and carries an #include (the c-include rule, replay_select.classify). The stored prompt does not carry the sentence. Ids end -cform-<spec>.sr-wollf-v7sr; meta.self_replay names the model, its adapter's sha (a9857c71…), the sample, the sampling, the verifier level and the answer's sha; an answer-form record in meta the form, the spec id, the sentence, the asked prompt's sha and the headers.

the 161
asked / kept / appended	167 prompts; 162 kept (157 at sample 0, 4 at sample 1, 1 at sample 2; 5 never compiled alone, all missing-header slips even under the sentence); 161 appended, one excluded because the seal guard read its prompt as a near-duplicate of a held-out item's (Jaccard 0.76; which one is recorded with the items, not here)
verifier level	compile 161 (function-only, standalone under the strict flags); 0 exec, since every prompt says "No main"
form	A (No main. Return only the code.) 142; B (Include any headers you need. …) 19
headers taught (rows carrying each)	stddef.h 101, string.h 26, stdint.h 20, stdlib.h 19, stdbool.h 14, limits.h 9, ctype.h 7, stdio.h 4
c-include class	97 → 258 (v4 carried 223)
median answer / code characters	277 / 268, code only, in the candidate's own terse form
wolf fraction	0.4724 (2,452 of 5,190)

Audit (the 4090 workstation): a standalone re-check of the whole built file gives 2,289 cases, 2,276 ok, 12 header-not-found (v7-sr36's own 12); all 161 appended rows are ok, all 161 are still classified c-include out of the built file, and the sentence is in none of their prompts. Contamination against the instrument's twelve item sets: 0 exact, 0 near. seal_heldout.py --heldout v3.1 guard: 5,190 rows vs 512 benchmark texts, 0 collisions (after the one exclusion; the first build had 1). 0 Magicoder rows. Release: the prompts are this project's own and the answers are the candidate's own outputs (the base's outputs plus a LoRA trained on this project's data), so the rows enter the CC BY 4.0 dataset with no new attribution; meta.license is cc-by-4.0 and meta.source_dataset wollf-answer-form.

What is not in this mix, and why. No diagnose-form rows: the candidate's 36 of 36 heldout diagnose samples per seed already open with a parseable verdict: line, and the corpus's 308 diagnose rows already answer in that form; the diagnose misses are content, not form. Not v7-sr36-inc's 28-row c-include dose: the follow-up found the dose is not the lever, and a second variable would make the reading unattributable.

corpus-v7-sr36-diag: diagnose rows whose verdicts the compiler writes (2026-10-09)

v7-sr36-diag = v7-sr36-form + 553 rows appended. corpus-v7-sr36-form's 5,190 rows byte for byte as the first 14,054,390 bytes (cmp on the 3090 Ti workstation), then 553 wolf rows, so against v7-sr36-form the one variable is those rows (and the step each row trains at). corpus-v7-sr36-diag/wollf-mixed.jsonl, sha256 5db8f33c6981a705ba6301720cbfad1b5706be20d474acc5131172f8be7fdc85 (read twice on the 3090 Ti workstation), 5,743 rows, 3,005 wolf (0.5232); mix-report.json, select-report.json and the build log are kept privately. Not the corpus of record: the model of record (v7sf3) trains on v7-sr36-form; this mix trained wollf-v7sd / -v7sd3 / -v7sd2 (held).

source programs	the wolf leg's own run/pass programs (meta.claim run(…) or pass), //! lines stripped, deduplicated: 2,117 seeds (3 skipped for use std.)
generator	diagnose_mutants.py (version 1.0, seed 20261008): 20 single-edit operators, one random eligible site per seed and operator, plus each unmutated seed, giving 12,369 candidates. No teacher model, no system prompt
label	the toolchain's, observed on the 4090 workstation under bwrap: wolf run, whose first error[EXXXX] is a rejection (with its headline message and line); a program that builds is kept only if wolf native and lupin conform-run agree on exit code, stdout or trap
pins	wolf 0.2.13 (4cc3dcd) / lupin 0.1.36 (a7f517e), the heldout's, and wolf 0.2.25 (6710f9e) / lupin 0.1.48; a row is kept only if both pins give the same verdict (59 candidates disagreed, 1,005 had no label at the first pin). Release archives, digests equal to the published ones
excluded	2,845 candidates by the private scan, kept with the items: ≥ 6 of any held-out item's K=8 signature shingles, or a diagnose item's shown program at 3-shingle Jaccard ≥ 0.35 / containment ≥ 0.5
selection	caps 20 per code, 2 per seed, 20 % per operator; rejections round-robin over codes; a running twin (the unmutated seed) for a sample of rejected seeds
rows	553: 358 rejections over 23 codes (16 codes at 20 rows, median 20), 175 running programs (110 running mutants + 65 twins), 20 traps
frames	six, this round's wording; four name an example code drawn at random from the pin's 142 documented codes, independent of the answer
answer	the verdict line in the instrument's form (harness.parse_diag_answer reads every one back, tested) + one sentence: the compiler's own headline message and line for a rejection
guards (the 3090 Ti workstation)	per-row scan of the 553: 0 rows at T, the most any row shares with any item is 5; seal_heldout.py --heldout v3.2 guard: 5,743 rows vs 512 benchmark texts, 0 collisions; contamination.py vs the instrument's twelve item sets: 0 exact, 0 near, 7 partial on MBPP+ (the base's own)

Before reusing it: the rows lift heldout diagnose 4 → 7 of 12 on three seeds and cost two to three wolf-program items at @1 against the same-card control.

corpus-v8: the record less its 24 near-twin rows, plus the diagnose rows rebuilt (2026-10-12)

corpus-v8 = corpus-v7-sr36-form − 24 rows + 531 rows appended. The corpus of record's 5,190 rows in their own order with the 24 near-twin wolf rows removed (rows whose program does what one of four held-out items asks; wh-004 19, wh-003 2, wh-009 2, wh-104 1; the ids are kept with the items), the 5,166 kept lines byte-identical (KEPT-IDENTICAL True in the build log), then 531 wolf rows. corpus-v8/wollf-mixed.jsonl, sha256 c7785647754af7ec75f0f848c73dc1cbe822d997759374bb2c49b548ed8da010 (read twice on the 3090 Ti workstation), 5,697 rows, 2,959 wolf (0.5194); mix-report.json, select-report.json and the build log are kept privately. Not the corpus of record: it trained wollf-v8a / -v8a3 / -v8a2.

the 531 rows	diagnose_mutants.py (this round's version 1.0): corpus-v7-sr36-diag's generator, operators, mutate seed (20261008), pins, private scan, caps and frames (see below), with two rules added and the 24 dropped rows seeding nothing: 2,096 seeds, 12,229 candidates
rule 1, --hold-out-qualified	no row's program writes an enum variant qualified (Name.Variant): 240 eligible candidates out. Why: at the heldout pin the native compiler abstains on a bare variant value but type-checks the qualified one and refuses == on it, so a program comparing enum values verifies only in the bare spelling; corpus-v7-sr36-diag's rows showed the qualified spelling at 8.3 % against the wolf leg's 4.8 % and every v7sd seed lost one held-out item to it. The wolf leg's own 118 such rows are untouched
rule 2, --require-valid-seed	a row is cut only from a seed whose unmutated program runs with the same verdict on both machines at both pins: 1,519 of 2,096 seeds; 2,717 candidates out. In corpus-v7-sr36-diag 105 of 553 rows came from a seed without that
label and pins	as corpus-v7-sr36-diag: wolf decides a rejection, a run needs wolf native and lupin conform-run to agree; wolf 0.2.13 (4cc3dcd) / lupin 0.1.36 (a7f517e) and wolf 0.2.25 (6710f9e) / lupin 0.1.48 (294d626), release archives read twice and equal to the published digests; 38 eligible candidates had no label at the first pin, 0 disagreed between pins
excluded by the scan	2,705 candidates (the private scan, kept with the items)
rows	531: 336 rejections over 21 codes (13 codes at 20 rows, median 20), 179 running programs (114 running mutants + 65 twins), 16 traps
guards (the 3090 Ti workstation, before any card)	per-row scan of the 531: 0 at T, the most any row shares with any item is 5; seal_heldout.py --heldout v3.2 guard: 5,697 rows vs 512 benchmark texts, 0 collisions; the row guard GREEN: 365 pairs, 365 accepted, 0 new, 0 grown (the record's 409 less the pairs the 24 rows carried); contamination.py vs the instrument's twelve item sets: 0 exact, 0 near, 7 partial on MBPP+ (the base's own)

Not changed here: the general leg's 21 substance rows (not yet decided).

Motivation

• Why: to teach an open code model a language that appears in no base model's pretraining data, without losing general coding ability. Hence two legs at 50/50: wolf, and general code as an anti-forgetting replay.
• Who: the wollf project at wolffe-lang, built between 2026-08-27 and 2026-09-14.
• Funding: self-funded; local GPUs, plus rented GPUs for later rounds.

Composition

One JSON object per line, schema wollf-sft/1: id, schema, leg (wolf | general), split (train), messages (one user turn, one assistant turn; no system turn in any row) and meta (provenance, below). Row ids and meta fields keep the project's internal provenance labels (machine names and work-log numbers) as written. There are no duplicate ids and no exact-duplicate conversations. The 21 groups of rows with identical assistant text are diagnose verdicts such as verdict: exits 11.

The wolf leg (2,580 rows, byte-identical in v2 and v4, sha 216fae8e…)

class (template)	rows	the assistant turn	the user turn shows
repair-wolf	518	a verified fixed program	a broken program and its diagnostic
explain-spec-wolf	447	a program demonstrating a clause	a quoted spec clause
oss-instruct-wolf	442	a new program	a corpus seed program
task-exit-wolf	437	a program whose exit code is the answer	a prose task
task-stdout-wolf	218	a program with exact stdout	a prose task
diagnose-wolf	197	verdict: rejected EXXXX + one sentence	a failing program
evol-instruct-wolf	148	a harder variant	a corpus seed program
diagnose-derived-wolf	120	verdict: exits N / prints "…"	a verified program
translate-to-wolf	53	a wolf translation	a Python/C/Rust snippet

• Generators (teachers): qwen3-coder:30b (Qwen3-Coder-30B-A3B-Instruct, 1,131 rows), Qwen3.6-35B-A3B Q6_K_L (1,110), GLM-4.7-Flash Q5_K_XL (339). Temperature 0.7, top-p 0.95, thinking disabled. Generated 2026-08-27T12:23Z – 2026-09-09T13:31Z. Per-row teacher, template sha, sampling seed and timestamp are in meta.
• Seeds: corpus feature programs 775, corpus failing programs 605, corpus run programs 590, spec clauses 447, synthetic fails 110, polyglot snippets 53.
• Verifier: verify.py, running wolf native (wolf build|run) and lupin (lupin conform-run) contained. A row enters only on PASS: an oracle reproduces the claim and none contradicts it. At generation 1,295 rows had both oracles agree; 502 were lupin-only (native not yet able to compile them), 120 wolf-only, and 663 differ only in form (e.g. pass vs exit(0)).
• Pins: generated at wolf c9da6d9 (0.1.0) 1,498, b482c52 424, 398e5f5 351, 5c729e8 307. Last verified: 2,153 rows at 0.2.8/0.1.28 (stamped meta.reverified_0_2_8), 120 at 0.2.7, and 307 (the 0.2.8 round's pairs) at their generation pin 5c729e8.

The general leg (2,580 rows)

source	v2	v4	license (hub card, re-checked 2026-09-15)	generated by (upstream)
ise-uiuc/Magicoder-OSS-Instruct-75K	1,132	1,018	MIT	gpt-3.5-turbo-1106 (card: "pay attention to OpenAI's usage policy")
glaiveai/glaive-code-assistant	1,032	925	Apache-2.0	Glaive's synthetic data platform
sahil2801/CodeAlpaca-20k	416	372	CC-BY-4.0	GPT-generated (Alpaca method; recorded in the older card)
wollf-node-js	—	265	Apache-2.0 (assigned)	Qwen3.6-35B-A3B, verified by node v26.7.0

Drawn from a 70,000-row normalized pool (seed 20260908), with forced replay classes (meta.replay_class): c-include 223, py-counter 158, and in v4 js-node-empty 265. A fourth source, Evol-Instruct-Code-80k, was excluded at fetch when its card changed to CC-BY-NC-SA-4.0. The 2,315 upstream rows are not execution-verified (meta.verified: false). Language guess in v4: python 1,486, unknown 395, javascript 322, C 226, java 58, rust 50, sql 25, cpp 18.

Balance against the benchmark (heldout-v3.1)

heldout leg	items	share of heldout	v4 rows	share of v4
wolf program	40	21.3 %	2,263	43.9 %
wolf diagnose	12	6.4 %	317	6.1 %
python	25	13.3 %	1,486	28.8 %
C	25	13.3 %	226	4.4 %
javascript	86	45.7 %	322	6.2 %
no heldout leg	—	—	546	10.6 %

Shares hide two mismatches:

• Program claims: 67 % of wolf program rows claim only exit 0 (843) or pass (672). The heldout asks for exit N (18), exact stdout (18) and traps (4), and training carries 2 trap claims.
• Diagnose answers: 197 code answers spread over 70 codes, at most 17 rows apiece. Five of the heldout's 12 answers are taught by no row (which five is recorded with the items, not here), and no row teaches a trap answer. rft-v1 adds 6 diagnose rows (0.1 %); v4 already had 317.

Collection process and verification

The foundry's notes and manifests, and rft-v1's notes on its three-way gate, are kept privately. The general pool was fetched by general_fetch.py on 2026-08-27, with licenses checked against a registry at fetch.

Preprocessing, cleaning, audit findings

Staleness: the language moved (wolf 0.2.14 / lupin 0.1.36, 2026-09-15)

Every wolf row was re-run through verify.py's verdict under the release archives, and every non-PASS and concurrency row ten more times.

• 127 of 2,580 wolf rows (4.9 %) no longer verify, in v2 and v4 alike.
  • 97 are newly rejected by the error-row discipline. Most are operators on a fallible !int (E0409, 63 rows).
  • 14 are rejected by lupin while native abstains.
  • 8 panic native codegen (wolf-lang#393).
  • 4 are nondeterministic select/close programs claiming one interleaving ([conc.select.fair]).
  • 2 diagnose rows answer a parse error the language no longer has (list literals, wolf-lang#154), and 1 answers a rejection of code that now compiles.
  • 1 times out.
• No row claims a retired code, and none fails for a syntax-family reason. The 56 rows flagged at 0.2.9 were never removed.
• rft-v1's 134 rows all verify three-way at the new pin. Only 1,211 of v2/v4's 2,580 wolf rows pass that stricter bar.

Contamination

Instrument: an exact 13-gram token index, comments kept, measuring what fraction of each benchmark text a row contains; plus the project's sealed guard (12-char shingles, Jaccard ≥ 0.5).

benchmark	texts	v4: exact / near / partial	named near hits
heldout-v3.1 wolf	104	0 / 1 / 231	one oss-instruct wolf row ~ one wolf item (0.79; a shared loop idiom, a different contract)
heldout-v3.1 general	408	0 / 1 / 9	one wollf-node-js row ~ one javascript item (0.52; shared idiom)
HumanEval+ 164, MBPP+ 378, MultiPL-E js 161 / cpp 161, IFEval 541, GSM8K 1,319, MATH-500 500, IFBench-MT 400, LiveCodeBench v6 175	7,723	0 / 0 / 18	—
MMLU-Pro 840	1,680	0 / 1 / 0	general.magicoder-oss-instruct.012861 ~ mmlupro-10363 (0.52, a 3×3 all-ones matrix literal; coincidence)
the book's exercises (wolf-book d636228)	258	5 / 41 / 44	corpus programs the book also quotes; rft-v1's 46 book-exercise rows copy their exercises (47 exact)

• The sealed guard finds 0 collisions for v2, v4, rft-v1 and v6.
• MultiPL-E (whose license forbids use as training data): 0 hits of any grade in any corpus, including against the HumanEval problems it translates.
• LiveCodeBench v6: 1 partial (a shared List[List[int]] signature). No problem text appears in any corpus.
• v2 and rft-v1 carry the same public-suite hits as v4. Against heldout-v3.1, v2 lacks v4's general near hit (the node-js row).
• Which row meets which held-out item is not named in this card: a row id beside an item id points at the item. The pairs are recorded with the items, in the private repository.

Truncation and form

• Truncation. Rendered through each base's own chat template and tokenized:
  • Qwen3.6-27B and Qwen3.8-27B: median 303, p99 1,023, max 3,271 tokens.
  • Gemma-4-31B-it: median 311, p99 1,092, max 3,233 tokens.
  • 1 row exceeds max_seq_length 2048 (general.glaive-code-assistant.026463). Its cut lands inside the prompt, so its answer never trained.
• Template consistency. Under both Qwen templates every training render starts with exactly the generation prompt the server sends, empty think block included (5,160/5,160). Under Gemma-4-31B-it's template none do: serving adds an empty thought channel the training render omits.
• Answer form.
  • Every wolf program row's graded block equals its verified source.
  • Every diagnose row parses with the harness's parser, and every answer states its verified claim. 39 answer multi-line stdout, a form the heldout's single-line diagnose never asks for.
  • 212 rows in the graded general legs (python 124, C 79, js 9) have no fenced code, so the harness could not grade a model that imitates them. This includes all 78 CodeAlpaca rows of the c-include class.
  • The harness's system prompt is in no row.

The verifying host, and what "compiles standalone" means

A gcc -c gate on generated C is host-dependent: an answer that is correct for a CUDA or Windows target is rejected by a machine without those SDK headers. The project's verifying-host rule (2026-09-16) therefore requires the verifying host's SDK set to be pinned and declared here, and a header-not-found rejection to be its own recorded class, never silently dropped.

corpus-v7's general half was verified on:

host	the 4090 workstation, Linux 7.2.3-1-cachyos-x86_64, glibc 2.44
C compiler	gcc (GCC) 16.2.1 20260810
include path	/usr/lib/gcc/x86_64-pc-linux-gnu/16/include, /usr/local/include, /usr/include
standard headers present	assert.h, ctype.h, limits.h, math.h, stdbool.h, stddef.h, stdint.h, stdio.h, stdlib.h, string.h, time.h
javascript	node v26.8.1 (node --check)
python	3.14.6 (compile())
containment	bwrap: ro-root, unshare-net, unshare-pid, 64 MiB file cap, 30 s CPU

The bar is the self-replay gate, not -fsyntax-only: C must compile alone under -Werror=implicit-function-declaration -Werror=implicit-int, so a missing #include is fatal. 12 rows in v7 name a header this host does not have (cuda_runtime.h, CL/cl.h, Windows.h, linux/init.h and others); each carries a header-not-found mark in meta and is kept.

The same gate is what makes the include repair exact: the compiler names the header (both gcc and clang do), the header is inserted, and the re-compile decides whether the repair worked. 2 rows in v6 were repairable this way, which confirms the verifying-host reading over an earlier one: the missing-#include defect is a handful of rows, not a class.

General-row quality

• The 265 node-js rows pass their own cases (265/265).
• Only 12 upstream rows carry self-tests: 5 pass, 4 need an absent module, 2 error, 1 does not parse, and none fails an assertion.
• Parsing every graded-leg code row:
  • 133 of 1,312 python rows do not parse (118 of them glaive).
  • 69 of 130 C rows do not compile standalone (35 on missing platform/project headers).
  • 1 of 39 javascript rows does not parse.
• (v2: 155/1,448 python, 69/130 C, 2/44 js.)

Uses

• Intended: research fine-tuning of code models on wolf, and replication of the wollf rounds against the sealed heldout (private; its seals and grades are kept with the project) and the public-suite instrument.
• Not suitable: evaluating wolf ability (use the sealed heldout, which is never trained on); teaching current wolf without v6's removals (4.9 % of the wolf leg teaches a language that no longer exists). Magicoder-derived rows are in no release mix (see Distribution).
• Known biases:
  • Qwen-family teachers dominate (87 % of wolf rows).
  • Programs are small: median 303 tokens with the prompt.
  • Claims skew to exit 0 / pass.
  • General rows are python-heavy (58 %).
  • The toolchain envelope excludes OS/net/fs programs.

Distribution

The dataset is released under CC BY 4.0. The model is released under Apache-2.0 (its card). The code in the wolffe-lang repositories keeps GPL-3.0-or-later and the wolf Runtime Library Exception.

What makes CC BY 4.0 possible

The wolf-leg prompts quote wolffe-lang text. In v4 (provenance table, the embeds_source_text column):

what the user turn shows	v4 rows	v6 rows	whose text
a wolf-lang corpus program or spec clause, found verbatim in the cited file at the generation pin	1,157 (corpus 793, spec 364)	1,093 (738, 355)	wolf-lang, GPL-3.0-or-later
a program or clause not matched verbatim: a re-flowed spec quote, or a teacher-written program (diagnose, derived and paired-repair rows)	715	689	wolf-lang or teacher output
a polyglot snippet (the foundry's polyglot set)	53	32	the foundry's own
no program: a prose task	655	638	the foundry's own

rft-v1's 46 book-exercise prompts quote wolf-book's exercises (GPL-3.0-or-later). No current row quotes wolf-std; the permission there covers future rows.

That text is GPL-3.0, and the Runtime Library Exception covers compiled output, not text. So wolffe-lang, as copyright holder, grants an additional permission under GPLv3 section 7: the wolf Training Data Permission, version 1.0, as LICENSE-TRAINING-DATA in wolf-lang, wolf-book and wolf-std. It permits training on the repositories' text and distributing excerpts of it in a dataset under CC BY 4.0, without the dataset becoming GPL, and says a trained model's weights and outputs are not a work based on that text. Its required attribution for the excerpts is "wolffe-lang (https://github.com/wolffe-lang)".

The permission is merged in all three repositories (wolf-lang#397, wolf-book#55, wolf-std#42, 2026-09-22), with the same text in each (sha256 39d16667…). Without it the wolffe-lang excerpts would be GPL-3.0 only and the dataset could not be released under CC BY 4.0.

Components of a release mix

component	license	obligation in the release
Wolf-leg prompts quoting wolf-lang, wolf-book (and later wolf-std) text	GPL-3.0-or-later + the wolf Training Data Permission, so CC BY 4.0 for these excerpts	attribution "wolffe-lang (https://github.com/wolffe-lang)"
Wolf-leg assistant turns and other prompts	teacher outputs: Qwen3-Coder-30B-A3B-Instruct and Qwen3.6-35B-A3B Apache-2.0, GLM-4.7-Flash MIT (hub cards, re-checked at the audit). None of these licenses restricts the outputs	none beyond the dataset's own
glaive-code-assistant rows	Apache-2.0	keep glaive's license statement in the card (below)
CodeAlpaca-20k rows	CC BY 4.0	attribution, license link, and a note that rows were changed (block below)
wollf-node-js rows	Apache-2.0 as assigned by the project	none beyond the dataset's own
the self-replay rows (replacing Magicoder)	the base model's outputs: Apache-2.0 (Qwen), no restriction on outputs	none beyond the dataset's own
Magicoder-OSS-Instruct rows	MIT, with an OpenAI usage-policy note on the card	excluded: zero rows in any release mix

The release rule: no Magicoder

Magicoder-OSS-Instruct-75K was generated by gpt-3.5-turbo-1106, and its card tells users to "pay attention to OpenAI's usage policy". The release rule removes that question rather than arguing it: a release mix carries zero Magicoder rows, judged by each row's source field (meta.source_dataset, or meta.hf_repo). The self-replay rows replace them. Enforced by release_rule.py and build_v6.py --release. A mix is marked for release by the token release in its name or "release": true in its manifest, and the rule refuses it unless it has no Magicoder rows and its manifest carries the CodeAlpaca attribution entry. v2 carries 1,132 Magicoder rows, v4 1,018, rft-v1 1,018, and v6 1,017 (build_v6 dropped general.magicoder-oss-instruct.012861 as contaminated). None of them is releasable, and test_release_rule.py pins v6's count from the committed tables.

Attribution

wolffe-lang. Wolf-leg prompts contain excerpts of the wolf-lang corpus and specification and the wolf-book exercises, by wolffe-lang (https://github.com/wolffe-lang), GPL-3.0-or-later, distributed here under CC BY 4.0 by the wolf Training Data Permission, version 1.0 (LICENSE-TRAINING-DATA in each repository). Excerpts may be reflowed or cut to a clause.

CodeAlpaca 20K by Sahil Chaudhary (https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k, from https://github.com/sahil280114/codealpaca), licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). Changes: rows were normalized into the wollf-sft/1 chat schema (instruction and input as the user turn, output as the assistant turn), drawn by seed, and some selected into replay classes. Provided as-is, without warranties, as the license states.

glaive-code-assistant by Glaive AI (https://huggingface.co/datasets/glaiveai/glaive-code-assistant), licensed under Apache-2.0. Rows were normalized into the wollf-sft/1 chat schema.

The manifest form of the CodeAlpaca entry is release_rule.py's CODEALPACA_ATTRIBUTION, which the release rule requires in every release manifest.

Base models and their licenses

Checked on 2026-09-15 against the Hub API and each license file, without a token:

base	Hub revision	license	notice file	a wollf on it ships under
Qwen/Qwen3.6-27B	6a9e13bd6fc8f0983b9b99948120bc37f49c13e9 (the snapshot wollf trained on)	Apache-2.0, LICENSE "Copyright 2026 Alibaba Cloud" (sha256 50cbab8a…)	none	Apache-2.0
Qwen/Qwen3.8-27B	1d4bf0f2ff6012fd82039f2fa52739d0dd7c60c0	Apache-2.0, the same text reflowed (sha256 bbedc3fd…)	none	Apache-2.0
google/gemma-4-31B-it	842da3794eaa0b77d5f08bae87a17459d91ff475 (last modified 2026-07-20)	Apache-2.0	none	Apache-2.0

Gemma: the audit recorded the page as gated. On 2026-09-15 the Hub API reports gated: false for google/gemma-4-31B-it (the id is case-sensitive; the lowercase id redirects), and the card's front matter is license: apache-2.0 with license_link: https://ai.google.dev/gemma/docs/gemma_4_license. That link resolves to ai.google.dev/gemma/apache_2, the Apache License 2.0 text through "END OF TERMS AND CONDITIONS" with nothing added. The older Gemma Terms of Use (last modified 2026-04-01) begin "The terms below apply to Gemma models listed in the Appendix … For Gemma 4 terms, see the Gemma 4 license", and the Gemma Prohibited Use Policy is incorporated by reference only through those older terms, so neither binds Gemma 4. The repository ships no LICENSE or NOTICE file. A Gemma-4-31B-it-based wollf could ship under the same terms: Apache-2.0, with a copy of the Apache text, a statement that the weights were modified, and "Gemma" used only to describe the origin (section 6, trademarks). The dataset's license does not change with the base.

Maintenance

• Maintained by wolffe-lang (https://github.com/wolffe-lang). The project repository is private.
• Re-verification rule: when the toolchain pin bumps, the wolf leg is re-verified, never assumed. Run staleness.py (extract → verify → recheck → summarize), then build_v6.py with the new tables.
• Contamination rule: every new corpus and every new benchmark goes through contamination.py and seal_heldout.py guard before a card is rented.
• Errata: the corpus-v7 round, which also added the verifying-host declaration and the answer-length tables, corrects two statements above: the "212 rows with no fenced code" are not unexplained rows (the wolf leg's explanations are inside the fence as comments, which the earlier count did not separate), and meta.lang_guess is unreliable (it tests python before C and matches print(), so 77 rows in v7 carry a corrected lang_guess with the original kept as lang_guess_general_mix.

rft-v2-q36 (2026-09-22): corpus-v7 plus the rft-v2 wolf rows

File: rft-v2-q36/wollf-mixed.jsonl, 5,786 rows, sha256 b840e289fa2d66061992fd5da4309e215756abbff1bff61d92dd2eafab09d564, read twice on the 3090 Ti workstation and equal to the shas.txt build-mix wrote. mix-report.json beside it. Not distributed and not trained; it is recorded here because its rows were verified in a way no earlier round's were.

Composition: corpus-v7 (b5ef6256…, 5,029 rows) in its own order, then 757 rft-v2 wolf rows appended: cand-diagnose 570, witness-diagnose 103, book-predict 17 (690 diagnose rows over distinct programs), witness-trap 40, book-exercise 20, witness-fail 7. corpus-v7's wolf leg is unchanged, so against rft-v2-q38 (not built, see below) the general half would have been the only variable, which is corpus-v7's design.

Provenance of the wolf rows, and what makes them different from every earlier round: every truth was taken by wolf 0.2.15 / lupin 0.1.37 running on the same rented card that generated the candidate, not on the dev box. The self-replay round verified on the dev box, and this round measured what that hides: on the droplet's Ubuntu 22.04 the released binaries do not start at all, and a partially-repaired toolchain answers exit(2) on every program that must run while --version prints correctly. A dev-box verification would have recorded those rows as gated. The pin is stamped in rft-v2-manifest.json; the installer and its two red-tested gates are kept privately.

Self-replay half, partial: 2,577 general rows were planned (dropped_slots: 0, tests 264, exec 1,784, carry 529; the v7 plan, reproduced on the droplet). Only 131 answers were generated before the rental's deadline, of which 56 verified and were kept (python 42, javascript 7, C 7; levels exec 48, tests 7, compile 1). So 56 general rows carry the base's own verified answer and 2,521 carry upstream text, against a design that wants all 2,048 verifiable rows replaced. replaced_by: {"python:exec": 42, "javascript:tests": 7, "c:exec": 6, "c:compile": 1}.

rft-v2-q38 was not built. It needs a Qwen3.8-27B self-replay pass that this rental did not fund; the 3.8 base GGUF was deliberately skipped (HF38=0) because nothing else needed it. Price to finish: about 1.3 h of card for gen plus 0.4 h for verify, per base.

Release posture: dropped_source_rows_after = 0, judged by the release rule's predicate (release_rule.py's is_magicoder: meta.source_dataset with meta.hf_repo as the second reading). Until this round, build-mix searched the whole row's JSON for the substring and so counted corpus-v7's 1,017 Magicoder replacements (rows corpus-v7 added to remove Magicoder, stamped with a fill record whose reason is "magicoder") as violations, returning exit 9 on a correct, Magicoder-free mix. Measured both ways on the real file, output byte-identical (dbdf7bec…), 1017/exit 9 before the fix against 0/exit 0 after it.