What was built, and every choice the protocol left open

§1Environment as executed

§2Model — src/model.py

Bidirectional (non-causal) pre-LN transformer over Mimi tokens, exactly grid.json → backbone: RMSNorm, RoPE, GELU MLP ratio 4, head_dim 64, no weight tying, one embedding table per codebook summed at the input, one linear output head per codebook. Non-embedding parameter count

verified for sampled configs to within 0.04 % of grid.json (the residual is the RMSNorm gains, which the formula excludes) — src/gates.py params.

Sequence layout (decision P0-1)

One sequence is [phonemes | audio frames]. At an audio position the input embedding is the sum of the eight codebook embeddings of that frame (MASK where masked, PAD where padded); phoneme positions use a separate table. RoPE positions are i for phoneme i and 512 + f for frame f. The fixed offset matters: audio positions must not shift with the phoneme padding length, otherwise a run's numerics would depend on micro-batch composition, and micro-batch size varies with model size under a fixed effective batch of 256. Padding is masked out of attention on the key axis.

μP realisation (decision P0-5)

Base width 256, multiplier m = w/256. Embeddings and RMSNorm gains: init std 0.02, LR = base LR. Hidden matrices: init std 0.02·√(256/fan_in), LR = base LR / m. Output heads: init std 0.02/√m, logits multiplied by 1/m, LR = base LR / m. Residual projections (attention out, MLP down) are additionally scaled by 1/√(2d) at init (grid.json residual_scale). The attention softmax keeps the standard 1/√head_dim because head_dim is fixed at 64 for every config in the grid, so the μP attention-scale correction would be a constant. Width transfer is measured at gate G1 and depth transfer at G1b — not assumed.

§3Data — src/data.py

Four idempotent stages: scan → select → phonemize → encode (plus eval_audio for the SIM-o references).

Prompt / target construction (decision P0-2)

Training. Each clip contributes its full phoneme transcript (always visible) and its full frame grid; the first 37 frames (int(3 s × 12.5 Hz)) are the always-visible prompt at all eight levels, the rest is the target region subject to masking. Clips longer than 18 s are excluded rather than truncated — truncating audio while keeping the transcript would break the text↔length correspondence the length conditioning depends on.

Evaluation (zero-shot cloning). The prompt is a complete held-out-speaker clip of 2.5–3.5 s together with its own transcript; the target text comes from a different clip (4–15 s) of the same held-out speaker. Visible phonemes are prompt-phonemes + <sp> + target-phonemes; the generated length is round(chars(target_text) · sec_per_char · 12.5) frames, capped at 187. This is the standard cross-sentence zero-shot protocol and needs no word-level alignment, which the corpus does not provide.

§4Training — src/train.py

SoundStorm-style coarse-to-fine masking, verbatim from grid.json → backbone.training_objective: per example a level l ~ U{1..8} and a ratio t ~ U(0,1]; levels below l stay visible, level l is masked i.i.d. with probability t, levels above l are entirely MASK; cross-entropy on the masked cells of level l only. Phonemes and the prompt frames are never masked. 30,000 steps, effective batch 256 sequences, AdamW(0.9, 0.95), weight decay 0.1 (on matrices; RMSNorm gains excluded), gradient clip 1.0, 600 warmup steps then cosine to 10 % of peak, bf16 autocast with fp32 master weights.

Config-independence of everything except (w, d, heads, seed) — decision P0-6

• Data order. A per-epoch permutation seeded by [seed, epoch]; within each group of eight batches the examples are sorted by frame count to cut padding waste. The order depends only on the seed, never on the model.
• Masking draws. Level, ratio and per-cell uniforms are drawn once for the whole 256-sequence effective batch from a generator seeded by (seed, step), before any forward pass — so two different shapes see bit-identical masks at every step.
• Loss normalisation. The masked-cell count of the entire effective batch is computed first; every micro-batch contributes Σ CE / total_cells. The gradient is therefore independent of how the batch was split into micro-batches (micro-batch size is chosen per config from a memory proxy, accumulating to exactly 256).

Validation every 1,000 steps is the protocol's definition: masked CE at the fixed ratios {0.25, 0.5, 0.75}, averaged over all eight levels, over the full 2,000-clip val split, with a fixed val-masking RNG (seed 999) shared by every run — so val losses are comparable across shapes. Checkpoints (model + optimizer + val history) are written every 1,000 steps and runs resume from them. Divergence uses the gate-G3 definition: val loss above 1.2× its running minimum at three consecutive evaluations.

§5Frozen sampler — src/sample.py

MaskGIT confidence decoding, level by level 1…8, exactly T refinement steps per level (NFE = 8T). Within a level, all target cells start as MASK; at each step the model scores every target position, a token is drawn categorically at temperature 1.0 (Gumbel-max on the log-probs), the confidence of the drawn token is its log-probability plus Gumbel noise scaled by 1 − i/(T−1) (annealed 1 → 0 across the level's steps), and the cosine schedule fixes how many cells remain masked after the step:

The highest-confidence cells are committed and stay committed; the rest revert to MASK. At T = 1 the schedule commits every cell in the single step, so the confidence ordering (and hence the noise) cannot affect the output — which is why the degenerate 1 − i/(T−1) case at T=1 is harmless (P0-4). Levels above the current level are fed as MASK, matching training; prompt frames and phonemes stay visible and unmodified throughout; padding positions can never be committed (their confidence is −∞).

Generation RNG matched across T (decision P0-3)

eval_zs items are processed in a fixed order (sorted by item id) with a fixed batch composition (50 items per batch) that is identical for every run and every T — item target lengths depend only on the text and the frozen sec_per_char, so even the padded tensor shapes match. All sampler randomness comes from a generator seeded by 20260805 + batch·10⁶ + level·10³ + step. Consequently a given item sees the same noise at the first step of every level for every T, every config and every seed, and no result depends on batch composition. An exactly matched stream for all steps is impossible in principle, because T changes how many draws happen.

Integrity (protocol §6.3). The token grids are saved per (run, T), and T=1 vs T=16 must differ on more than 20 % of cells before any metric is computed — the check that separates "steps genuinely don't help" (a finding) from "T isn't wired through" (a bug). The same check runs on an untrained model at gate G0(e).

§6Evaluation — src/evaluate.py

• WER. Whisper-large-v3, greedy, both reference and hypothesis passed through the Whisper English normalizer; per-item WER via jiwer, plus the corpus-level WER as a robustness column. Primary metrics are computed over all items — degenerates included (protocol §1); non-degenerate variants are reported separately.
• SIM-o. Cosine similarity between the SV embedding of the generated target audio and of the ORIGINAL prompt waveform (not the codec reconstruction).
• Degenerate rule (§6.4, frozen). Empty normalised transcript, or fewer than 30 % of the target character count, or some 4-gram repeated at least six times consecutively.
• UTMOS22-strong as a tertiary, droppable metric.
• Crash policy (task.md §10). An item that cannot be read scores WER = 1.0, degenerate = true, is excluded from SIM/UTMOS, and is counted in a crash-rate column.
• c_layer(width) (§6.5). Measured per distinct width at batch 1 on the eval GPU (200 phoneme + 224 frame positions), reported as ms per layer per step; the design-rule table uses latency = 8·T·d·c_layer(w) with these measured values only.

§7Statistics — src/fit.py

Weighted non-linear least squares (scipy least_squares, trust-region reflective) with 32 multi-starts from RNG 42 and the protocol's bounds; Part A on the 15 config means at T=16, Part B on the full 75-point surface; weights 1/SE² with SE taken over seeds and the pooled within-config SD substituted where a config has a single seed (floored at 1e-3 so a chance agreement between two seeds cannot dominate the fit). AICc uses the weighted RSS with k = parameters + 1. The bootstrap is run-level as the protocol requires: for each config its runs (seeds) are resampled with replacement, every T point is recomputed from the resampled runs, and both parts are refitted — 2,000 replicates, RNG 7331, percentile CIs. The decision block then applies H-D1…H-D4 and the S1/S2/F1/F2 routing mechanically, after gate G4.

§8Orchestration — src/orchestrate.py

A thread-pool scheduler places each run entirely on one GPU (task.md §2 forbids sharding a run) and can place more than one run per GPU where utilisation is low — the narrow configs use a small fraction of a B200. GPU-hours charged against gate G5 are the sum of per-run wall time, which over-counts under co-tenancy and is therefore conservative; the exact per-GPU occupancy (union of intervals) is also recorded in state.json. state.json carries phase, active grid, active recipe, T semantics, chosen LR, completed/failed runs, gate results, cut history and compute; every gate evaluation with its measured values is appended to LOG.md.

§9File map and reproduction

python src/data.py all                      # scan, select, eval_audio, phonemize, encode
python src/gates.py all                     # G0 (a), (b), (e) + param-count test
python src/evaluate.py gt                   # G0 (c) on ground-truth audio
python src/orchestrate.py phase1 --per-gpu 3      # muP sweeps -> G1, G1b
python src/orchestrate.py train --phase 2 --configs A3,B3,C3 --seeds 0
python src/orchestrate.py train --phase 3         # remaining mandatory grid
python src/orchestrate.py phase4                  # synthesis at every T
python src/orchestrate.py score                   # WER / SIM-o / UTMOS
python src/evaluate.py collect                    # results/artifacts/runs.csv
python src/fit.py                                 # results/artifacts/fits.json (+ G4, H-D1..4)
python src/figures.py && python src/report.py     # figures + docs/results.html
python src/paper.py                               # populate aspect-d-paper/main.tex

§10Deviations and fallbacks (full list in LOG.md)

ASPECT-D · implementation reference · generated during the execution run; the authoritative trail is LOG.md and state.json.