# duel_corpus — credit-assigned SFT data from SN97 duel artifacts

Built from the 200 eval runs the dashboard still exposes. The core idea: the
judge answers questions about a whole trajectory, but 81% of its explanations
name the `CANDIDATE OUTPUT N` block that satisfied each question. That citation
is the only per-turn reward signal SN97 emits, and it is free — other miners'
GPU time already paid for it.

## Pipeline

| step | script | output |
|---|---|---|
| 0 | `harvest_all.py` | `raw/` — 400 artifacts, 5.93 GB, 19,811 scored samples |
| 1 | `build_turn_corpus.py` | `turns.jsonl` (506,201 turns), `samples.jsonl` (39,622 sides) |
| 2 | `select_targets.py` | `sft_duel_credit_v1.jsonl` — 4,751 rows |
| 4 | `validate.py` | `sft_duel_credit_v1.clean.jsonl` — **4,664 rows, 22,762 train turns** |

Re-runnable end to end; the harvest resumes if interrupted.

## Output format

Drop-in for `sft/data.py`: a full `messages` list where assistant turns that
should receive gradient carry `train: true`. Everything else stays as context,
which is the point — the model must see the states it will generate from,
including the failed ones.

Each row also carries `train_meta` (per-turn earned weight, tags, `is_recovery`,
`cmd_kind`) so composition can be reweighted at training time without a rebuild.

## What the corpus says

Turn credit is not uniform. Mean credit earned by a turn, by command:

| command | share of turns | mean credit | % earning |
|---|---|---|---|
| `cat -n` | 9.8% | 1.350 | 44.3% |
| `sed -n` | 14.1% | 1.165 | 40.6% |
| `cat` | 14.6% | 0.866 | 37.0% |
| edit | 1.9% | 0.716 | 41.3% |
| `grep -r` | 4.2% | 0.487 | 30.0% |
| `pytest`/`python` | 11.2% | 0.247 | 21.8% |
| `find`/`ls` | 10.4% | 0.186 | 18.1% |
| submit | 0.4% | 0.153 | 9.5% |

Displaying file content earns 5-7x what `find`/`ls`/`pytest` earn, and those two
low-value kinds are 21.6% of all turns in the wild. That is the waste.

Credit is also strongly front-loaded — turn 1 earns 1.523, turn 15 earns 0.186.
The first three turns are where a sample is won.

Exposure bias is measurable here: 19.2% of turns get a failed observation, and a
turn following a failure earns credit only 18.8% of the time against a 30.3%
baseline. A single bad command costs ~40% of the next turn's expected credit.

## Composition of the built dataset

24,472 selected train turns before validation, 22,762 after:

- command mix: `cat -n` 18.1%, `sed -n` 16.9%, `cat` 16.2% (51% display), `find`/`ls` down to 5.9%
- earned tags: grounding 35.6%, explore 29.6%, claims 20.9% — 86% on the three tags carrying 89% of duel weight
- 2,841 recovery turns (earned credit immediately after a failed observation), present in 41% of rows
- source sides average 0.941 score, deduped to one side per `sample_id`
- 4.2M trainable tokens; mean sequence 9,394 tokens, 0.4% over a 32,768 limit

## Gates applied

Run with the validator's own `loop_check` and `observation_format`:

- source side must be non-looped, score >= 0.85, `dup_cmd_ratio` <= 0.45, `max_cmd_run` <= 3
  (validator kills at 0.65 / 6, so there is margin)
- a repeated command never receives gradient
- train turns must contain exactly one bash block, no unclosed `<think>`, no
  duplicate command among targets — violations are demoted to context, not dropped
- 100% of train turns tokenize with `sft/data.py` and their label span decodes
  back to exactly the assistant content

## The escape set — `build_escape_set.py`

The Phase 2 filter above selects per *side*, and that quietly recreated the
problem it was supposed to fix: requiring score >= 0.85 and low repetition threw
out every trajectory that demonstrates being stuck. It kept 8,021 of 39,622
sides and captured only 16.8% of the available recovery material (2,805 of
16,650 turns).

`build_escape_set.py` selects per *turn* instead. A turn qualifies when it
earned judge credit and the state before it was bad — previous observation
failed, or previous commands were repeating. The degenerate prefix is kept
verbatim with no gradient; only the escape trains. A side that scored 0.3
overall still contributes its one good escape, because per-turn credit is
verified per-question regardless of the side's total.

`sft_escape_v1.jsonl` — 13,979 rows, 7,655 unique samples:

- **73.7% come from sides Phase 2 rejected** — that is the material that matters
- 98.3% follow a failed observation, 1.8% follow a repeat run
- prior consecutive failures: mean 1.29, max 10
- escapes are mostly reads: `cat` 19.2%, `grep` 18.5%, `cat -n` 14.1%, `sed -n` 13.5%
- 100% tokenize clean, median 8,006 tokens, 1.8% over 32,768

## Combined output

`sft_final_v1.jsonl` — 18,643 rows, 36,741 gradient-bearing turns, 861 MB.
4,664 credit rows (what winning looks like) + 13,979 escape rows (how to get
out of trouble). Rows carry `mix` = `credit` | `escape` for reweighting.

## Judge-free local scorer

SN97 scores a trajectory by asking an LLM judge yes/no questions. The questions
are *in the artifacts* — what we lack is only the judge. So `build_local_scorer.py`
featurizes each question against a trajectory and `fit_local_scorer.py` fits a
classifier to answer it. Train/test split is by eval run, so evaluation never
sees a duel it was fit on.

| step | script | output |
|---|---|---|
| features | `build_local_scorer.py` | `scorer_features.jsonl` — 39,622 sides, 565k questions |
| fit | `fit_local_scorer.py` | `local_scorer.pkl` (gradient boosting) |
| use | `score_local.py --build-index` then `--trajectories mine.jsonl` | `local_scores.jsonl` |

Requires the venv at `/root/.venv-tok` (numpy, scikit-learn).

### Measured accuracy, held out

| what | number |
|---|---|
| per-question accuracy / AUC | 0.771 / 0.849 |
| per-side score correlation | pearson 0.727, **MAE 0.140** |
| paired same-sample: picks the better side | 70.0% |
| duel margin sign agreement | 73.3% |
| per-model ranking (57 models) | spearman 0.561 |
| loop detection | **exact** — runs the validator's own `loop_check` |
| catastrophic flag at <0.35 | precision 0.820, recall 0.384 |

### What this is and is not good for

**Trustworthy:** catching loops before you submit (exact, and it is what banned
two of your hotkeys); flagging which specific samples the model falls apart on
(82% precision), which matters because 70% of the gap to the king lives in
samples scoring under 0.34.

**Only with enough samples:** the per-sample error is 0.207, so a 100-sample run
gives +/-0.041 at 95% — wider than the 0.025 margin that decides a duel. It takes
**500+ paired samples to resolve 0.025**, 1000 to be comfortable. Generate on
500–1000 samples, not 100.

**Not trustworthy:** any single sample's score (MAE 0.140), and ranking two
models that are genuinely close.

End-to-end check on a held-out run: predicted 0.5804 against the judge's 0.5779.

## Window B — `../mini_coder/mine_window_b.py`

Duel artifacts stop at turn 16, so they contained only **243** escapes out of a
repeat run and nothing at all past the cutoff where pre-eval's tail judge looks.
`mini-coder` (`ricdomolm/mini-coder-trajs-400k`, 9.4 GB, 396,382 trajectories)
covers exactly that region: mean 33 assistant turns, and 99.9% end in a submit.

Two products, suffix-masked the same way:

| product | rows | what it teaches |
|---|---|---|
| `escape` | 6,820 (**28x** the duel corpus; 41.3% past turn 16) | a command repeats, a *different* command breaks out — gradient on the escape only |
| `finish` | 177,559 mined, capped to 16,000 | concrete non-repeating tail work on verified tasks, plus the closing submit |

`finish` is capped at one row per instance because 177,559 rows come from only
20,267 instances; uncapped it would swamp the duel material and pull the model
toward mini-coder's style in the window that decides duels.

## Final mix — `build_final_mix.py` -> `sft_final_v2.jsonl`

**41,463 rows, 59,561 gradient-bearing turns, 1.69 GB.**

| mix | rows | share | train turns | window | purpose |
|---|---|---|---|---|---|
| `credit` | 4,664 | 11.2% | 22,762 | 1–16 | what earns judge credit |
| `escape_duel` | 13,979 | 33.7% | 13,979 | 1–16 | recovery from a failed command, on-policy |
| `escape_mini` | 6,820 | 16.4% | 6,820 | 5–32 | breaking out of a repeat run |
| `finish_mini` | 16,000 | 38.6% | 16,000 | 17–32 | surviving to a submit in 32 turns |

Every row carries `mix`, so ratios can be changed without a rebuild.

Tokenizer validation across all four mixes: **100% of sampled train turns
encode cleanly and their label spans decode back to exactly the assistant
content.** Median sequence 7,798–9,110 tokens; only `escape_duel` has material
overflow past 32,768 (2.0%).

### Coverage against the two gates

| failure | share of chelsea-blue's pre-eval failures | covered by |
|---|---|---|
| looping | 5/10 | `escape_mini` (6,820, 41% past cutoff) + `escape_duel` |
| no submission / no edits in 32 turns | 2/10 | `finish_mini` (16,000, 8,776 submit turns available) |
| duel score gap | — | `credit` + `escape_duel` |