iamPi/tessera-8a92b237

tessera — corpus epoch 13, full sweep

Teacher-anchored SFT data harvested from every published Affine (Bittensor SN120) duel scored against corpus epoch 13 — 230 duel records, chal-00760 through chal-01102, covering 2026-08-16 to 2026-08-24.

42,006 rows over 42,006 distinct turns (one row per turn), drawn from 4,981 trajectories and 3,751 strata. That is 70% of the 59,745-turn epoch-13 corpus, and 2.3× the 18,138 rows of iamPi/tessera-77d11909, which sampled a subset of the same epoch from the first 76 duels.

Nothing here is private: the subnet publishes every duel record (s3.hippius.com/affine-sn120/evals/) and the corpus behind it (.../turns/), and invites training on the teacher_refs field. The teacher is the subnet's frozen zai-org/GLM-4.5-Air-FP8.

Completion format

</think>
THOUGHT: {thought}

The analysis is complete. Next command:

```bash
{command}

The prompt ends inside an open `<think>` block, so the completion opens with
`</think>`. Every completion round-trips through the validator's own
`split_rollout` ([`evalsrv/chat.py`](https://affine.io/code/evalsrv/chat.py))
to exactly the `(thought, action)` stored in the columns — 42,006/42,006.

The trailing cue is the exact suffix the reigning king
(`vera6/affine-5g4yy75zuz-t6`, reign 36) emits on 99.4% of its own duel
thoughts.

## How a row is chosen

1. **Pool** every teacher reference for a turn across all 230 epoch-13 duels
   — 816,661 references over 49,577 distinct turns.
2. **Consensus**: take the most common *first token* of the pooled bash
   commands. `modal_share` is its share of the pool — that is, whether the
   teacher's samples agree on *which command to run*, not on its exact text.
3. **Select** the reference with the highest lift
   (`lp_own − lp_empty`) among those whose command starts with the modal
   token. `teacher_lift` is that lift.
4. **Join** metadata from `turns/index/turns_0013.parquet` and render the
   prompt as `apply_chat_template(prefix, add_generation_prompt=True)`,
   appending `<think>` if the template does not already end with it.

This recipe was reverse-engineered from `tessera-77d11909` and verified
against it: prompt bytes 15/15 byte-identical, `n_prefix_tokens` 15/15,
`teacher_lift` 18,138/18,138, `modal_share` 17,545/17,545 on turns whose pool
reproduces exactly.

The tokenizer is the king's own (`vera6/affine-5g4yy75zuz-t6`, a
`qwen3_5_moe`); `n_prefix_tokens` is the token length of `prompt`.
Note `n_prefix_chars` is the corpus's measure of the raw messages and is
**smaller than `len(prompt)`**, which adds the chat-template wrapper.

## Filters

| dropped | rows |
|---|---|
| thought under 80 chars after cleaning | 5,753 |
| prompt over 30,000 tokens | 867 |
| duplicate `(prompt, completion)` pair | 0 |
| teacher lift ≤ 0 | 513 |
| blank thought or action | 397 |
| invalid shell syntax (`bash -n`) | 35 |
| hallucinated environment turn in the thought | 6 |

The 80-char floor mirrors the live contract's `min_thought_chars` and is
measured on the **bare thought**, before the cue is appended, so boilerplate
cannot lift a thin thought over the gate. The token cap keeps every row
inside a 32k context (max observed total: 31,314 tokens). The `bash -n` pass
parses each command without executing it and drops the ones that are not
valid shell.

## Format repairs

Teacher rollouts leak their own reasoning scaffolding — the corpus system
prompt literally instructs the format with a `<format_example>` block
containing `THOUGHT:`, and the teacher echoes it back. Every completion was
normalized:

| repair | rows |
|---|---|
| `<think>` reopened right after the `THOUGHT:` label | 17,010 |
| >1 ```bash block — kept the first, dropped the rest | 803 |
| second `THOUGHT:` label mid-thought | 613 |
| corrupt prefix before a restarted label, dropped | 505 |
| truncated label debris (`THO`, `UGHT`, `THOTHOUGHT:`) | 434 |
| substantive pre-label reasoning merged into the thought | 108 |
| stray `<thinking>` / `<thought>` / `<format_example>` | 91 |
| orphan token glued to a colon | 7 |

`clean_flags` records which repairs applied to each row.

## Columns

`prompt`, `completion` — the training pair.
`thought`, `action` — the parts, with `thought` **excluding** the cue (use it
for length filtering; the cue lives only in `completion`).
`teacher_lift`, `n_pool_refs` — reference quality signals.
`turn_id`, `traj_id`, `stratum`, `source`, `language`, `phase`,
`n_prefix_chars`, `n_prefix_tokens`, `duel_epoch` — provenance.

### Three notions of teacher agreement

The pool for a turn holds several teacher samples. How much they agree depends
entirely on how strictly you compare their commands, so all three are shipped:

| column | compares | mean | median | unanimous |
|---|---|---|---|---|
| `modal_action_share` | byte-identical command | 0.417 | 0.333 | 12.8% |
| `modal_norm_share` | command after representation normalization | 0.428 | 0.333 | 14.0% |
| `modal_share` | first token of the command only | 0.786 | 0.833 | 35.3% |

`n_distinct_actions` is the number of distinct commands in the pool.

The normalization behind `modal_norm_share` erases quoting and whitespace
differences, strips a leading `cd DIR &&`, drops `./` prefixes and the common
`/testbed`, `/app/task_file`, `/workspace` cwd prefixes, and folds
`python3`→`python`. It merges cases like `node /app/task_file/solution.js`
with `cd /app/task_file && node solution.js`. It is deliberately conservative:
a command containing a heredoc is compared by its raw body, never tokenized,
because tokenizing mixes the document text into the argument list and can
collide two scripts that merely look alike.

The important number is the gap. Normalization buys only **+1.1 points** over
byte-exact matching — most teacher disagreement is *genuine* (different
commands entirely), not cosmetic. `modal_share`'s 0.786 is a far weaker claim
than it looks: agreeing that the next command starts with `cat` is not
agreeing on what to do. Filter on `modal_action_share` if you want turns where
the teacher actually converged.

## Mix

`source`: swe 20,529 · terminal_lego 15,461 · scaleswe 2,208 ·
terminal_bench_2 1,055 · nl2repobench 781 · r2e_gym 527 · swerebench_v2 522 ·
multiswe 332
`language`: python 24,337 · shell 16,516 · js 203 · go 185 · ts 174
`phase`: early 15,454 · mid 13,024 · late 10,157 · empty 2,780
(`phase` is blank for a subset of `swe` turns in the corpus itself.)

Prompt tokens: median 6,381, p95 23,537, max 29,992.
Thought chars: median 186, p95 507. Action chars: median 85, p95 2,007.

## Caveats

- **The repo mix is skewed by construction.** Duel turn selection
  round-robins over `repo|phase` buckets, so a repo's weight tracks its PR
  count, not its data volume. `stratum` and `source` are per row — reweight
  if that is not what you want.
- **`modal_share` is vacuous when `n_pool_refs == 1`** (it is trivially 1.0).
  Median pool size here is 10, versus 4 in `tessera-77d11909`, because this
  build pools 3× as many duels.
- **Deduplication is on the `(prompt, completion)` pair only**, and there are
  **zero** such duplicates: every row is a distinct turn with a distinct
  prompt. 763 rows share a completion with some other row under a *different*
  prompt — the same command is a different lesson in a different context, so
  those are kept. The most repeated completion is a turn-0 opener paired with
  `ls -la`, appearing 621 times; if that concentration is not what you want,
  filter it yourself rather than assuming it was filtered for you.
- Use the **standard (non-conversational) prompt-completion** dataset type in
  TRL's `SFTTrainer` — these are plain strings, so no chat template should be
  applied on top. Set `max_length` to at least 32,768; the 1,024 default
  silently drops every example.