build_tierlist.py grades EVERY hand-cut loop in the Samples corpus with the Foundry
katana (engine/grade.py — DRY, one rubric) and joins each kit against how often PLN
actually plays it (`s "kit"` track-counts from catalog_view.json). 1690 wavs across
97 loop-kits graded in parallel (~98s, 6 workers). Tiers: 4 S, 3 A, 24 B, 51 C, 15 D.

The point of #11 was never the ranking — it's VALIDATING the rubric against reality
(PHASE2_FINDINGS §5b): do the kits PLN reaches for grade higher? Result:
grade↔usage Spearman ρ = +0.34 — positive, the katana points the right way.

The confound is the interesting part. The single most-used kit, `risers` (16 tracks),
tiers only C — and that's CORRECT: risers are FX sweeps, they go quiet→loud and never
wrap cleanly, so they fail seam + bar-consistency by design. They're heavily used as
one-shot transitions, not loops. Same for weird_dialogs. So loop-mechanical-grade and
usage diverge exactly where they should — for non-loop material. Filtering FX out would
lift ρ; the divergence is a feature (it tells loops from FX), not a rubric failure.
Meanwhile PLN's custom `f*` palette validates the rubric from the other side: fsynth,
fguitar, fmono all land A-tier; fpiano/forgan/fbreak* B. S-tier exemplars: simmons,
electrn, samples-cello-plucked, ouais.

Caveat logged for follow-up: only 34/97 kits matched a usage token (folder name vs
`s`-token mismatch for the rest, and catalog_view covers 73 tracks) — the correlation
is over those 34. The grader's v1 thresholds (noisy dc-offset flag at 1e-4, seam dB
cutoffs) are the next calibration lever now that we can measure against the corpus.

7 pure-logic tests (spearman incl. ties/inverse, usage = tracks-not-occurrences,
tier thresholds mirror the grader). Next: tierlist.html showcase (Ship's Bridge + impeccable).

A second model (Sonnet) independently labeled all 534 tracks; emotion_drift.py
measures where it disagrees with the opus GT. Result:
  mean V/A drift     0.322
  quadrant agreement 72%
  emotion Jaccard    0.53
  174 uncertain-GT tracks (top-quartile drift or quadrant mismatch)

The disagreements aren't noise — they CONCENTRATE on genres that straddle the
circumplex, which is a real finding:
  - hardstyle (The Prophet, Headhunterz): triumphant/euphoric (+,+) vs
    aggressive/tense (-,+) — the genre's 'euphoric aggression' lives on the
    quadrant line.
  - uplifting trance (Cosmic Gate, Ferry Corsten, Markus Schulz): euphoric vs
    driving/tense — same boundary.
  - neoclassical (Nils Frahm, Ólafur Arnalds, Max Richter): calm-positive vs
    melancholic-calm.

So ~33% of the corpus carries genuinely uncertain emotional GT, and it's
predictable WHICH third. Those tracks should be down-weighted (not trusted) in
the upcoming scale calibration — single-model GT would have hidden this.

Overnight scale-up. A workflow fanned 24 opus subagents over genre cells —
electronic-heavy (Detroit/Chicago, modern techno, house, trance, dnb/jungle,
dubstep, garage, ambient, IDM, trip-hop, dub, synthwave, EDM, minimal, French
touch, hardcore, deconstructed, lofi) anchored by canon + diversity (hip-hop,
rock/metal, soul/funk, jazz, world, modern classical). 480 authored → 475 unique
→ 474 merged (1 dup, 0 invalid: schema enforcement on the 12-emotion vocab +
V/A range held perfectly).

Coverage: all 12 emotions, 289 genre tags, every V/A quadrant >> floor (thinnest
--=47). Labels ring true — Cybotron 'Clear' cold/hypnotic, 'Strings of Life'
euphoric, Jeff Mills 'The Bells' hypnotic/tense, de Witte dark/aggressive.

PLN's 'dataset size is the lever' — 9x the corpus for the scale calibration the
n=5/n=60 reads couldn't settle. Audio fetch/analyze runs overnight (disk-safe).

Three tools for the unattended ~6h night run that scales the emotion GT corpus
and validates it across models:

- emotion_corpus_merge.py — fold model-authored GT batches into the corpus
  SAFELY: validate vs the fixed 12-emotion vocab + V/A range, dedup by slug AND
  by normalized artist|title (no track twice under two slugs), default the
  yt-dlp query. Idempotent.
- emotion_overnight.py — disk-safe (volume at 97%%), deadline-bounded grind:
  phase 1 fetch→whole-mix→delete mp3 over the whole corpus (bank the cheap
  signal first); phase 2 re-fetch→demucs stems→delete for as many as the
  deadline allows (grows the #92 stem evidence base). Per-track try/except,
  yt-dlp throttle + consecutive-failure backoff, audio purged after every track.
- emotion_drift.py — cross-model agreement on the GT itself: a second model
  (sonnet) labels the same tracks; high opus-vs-sonnet V/A drift or quadrant
  mismatch flags UNCERTAIN ground truth to down-weight, not trust. Single-model
  GT is a blind spot — a second pair of ears finds it.

Spirit of PLN's overnight brief: scale the dataset (the lever), and check
cross-model drift instead of trusting one model's priors.

A pure grade(wav) -> LoopGrade that scores ANY sample against the empirical
A-profile + the B mechanical rulebook (PHASE2_FINDINGS §2-§3, §5a): seam click,
zero-crossing cleanliness, DC offset, bar-length self-consistency, level sanity,
bass mono-compatibility, and the one-shot/loop class. Composite 0-1 → S/A/B/C/D
tier + per-rule sub-scores + human-readable flags. This is step 1 of the phase-2
build order — the instrument the finder (#5) and the Hall of Fame tierlist (#11)
both reuse (DRY, feedback_build_katana_first): the finder grades hypothetical
windows, the tierlist grades existing files, same sub-scorers.

Two findings while validating against real ParVagues loops (crimewave/diams_dj/humpty):

1. bar-consistency was DEAD — `librosa.feature.rhythm.tempo` doesn't exist in
   librosa 0.11 (it's `librosa.feature.tempo`), so a swallowed AttributeError sent
   every file down the no-tempo fallback → a flat 0.50 for all. Fixed; now crimewave
   drums correctly reads as 4 bars @ 121.9 bpm (matches the GT note ~121.8).

2. seam was measuring the single-sample wrap step |x0-x[-1]| vs the signal's MEAN
   step — which unfairly punishes a loop for wrapping at a zero crossing (the
   steepest point: a *perfect* integer-period sine scored only 0.40). §3 wants
   waveform CONTINUITY, so seam now measures the second difference (jerk) at the
   wrap, |x0 - 2·x[-1] + x[-2]|, normalized by typical curvature — captures both a
   value jump and a slope break, and a clean wrap now grades ~1.0.

Sanity: crimewave (a core-palette kit) lands mostly B-tier or above, with clipping
/off-grid cuts correctly sunk to D — consistent with §5b's "core kits must tier high"
validation target. The composite WEIGHTS + THRESH are tagged v1/provisional: the
dc-offset flag is still noisy (1e-4 is spec-strict) and the seam dB cutoffs want
calibrating — that's #11's job (corpus-wide grade↔.tidal-usage correlation), not
eyeball-tuning on 3 kits. 28 tests pass (synthetic signals, relative assertions).

Runs under system python3 (numpy/scipy/soundfile/librosa already present); no GPU,
no network. CLI: python3 -m engine.grade <wav>… [--json].

Task #8. Question: is a SOTA Mel-/BS-Band Roformer reachable on the 6GB RTX 2060,
or are we stuck on demucs? Answer: it fits comfortably — but the wall was never VRAM.

Run 1 (system python 3.14) died at model instantiation: audio-separator's Roformer
loader carries `Callable | None` type hints that beartype rejects under 3.14
(BeartypeDecorHintNonpepException on `stft_window_fn`). Peak VRAM at crash: 921 MiB —
nowhere near the limit. So engine2 is gated on the interpreter, not the card.

Run 2 (python 3.12 venv) succeeded: bs_roformer_ep_317 separated the 164s Loituma
source in 90s (~0.55× realtime) at a peak of 3051/6144 MiB — half the card, ~3GB
headroom. torch 2.12.1+cu130, onnxruntime-gpu 1.27, CUDA detected fine.

Caveat for the wiring task (#9): ep_317 is a 2-stem model (Instrumental/Vocals); the
Foundry contract is 4 stems (drums/bass/other/vocals). #9 must pick a 4-stem Roformer
checkpoint and re-confirm VRAM — but with 3GB to spare on a 2-stem pass, a 4-stem run
is plausible. The spike is self-contained + idempotent (research/engine2_spike/spike.sh,
SPIKE_PY pins the interpreter); result.json carries the numbers.

The origin-vs-sound mismatch as a feature: a pack defined by where a sound came
from (a song, a machine, a console) is expected to span the family wheel, and
that scatter is the story. Layered grouping discipline = same as the folder: a
hint to compare against, never a law.

PLN's insight: the FOLDER is a loose convention, not the true grouping. rample*
is ONE bank sliced A0..S57; 808* is one drum machine split per voice; *_commodore
is one chip sliced by role. So adds the PACK granularity above the folder —
per-pack / per-folder / per-sample, weakest-to-strongest binding (per-sample stays
the only ground truth).

sample_packs.py: a curated REGISTRY (drum_machine / bank / chip / source / genre)
+ an auto-grouper (prefix-before-digit & underscore head/tail tokens, ≥2 folders)
that PROPOSES packs the registry missed — it caught trance_* and voices_*, now
folded in. A pack needs ≥2 grounded folders (a 1-folder pack is just a folder; it
may gain siblings when #84 grounds all 718 — provenance notes this).

Rolls the per-SAMPLE family counts up to the pack and asks the real question:
does a pack live in one audio family, or span the wheel? 22 packs over 83/150
folders; 15 of them deliberately span multiple families:

  rample  → 8 families (snare/kick/hat/fx/break/pad…) — a bank IS a grab-bag
  jungle  → 11 families — a whole genre's kit
  808     → kick/hat/perc — one machine, three voices
  commodore → bass/fx/pad/lead/synth — the chip, every role

That origin-vs-sound mismatch is the point, not noise: a pack defined by ORIGIN
(a song, a machine, a console) is EXPECTED to scatter across the audio clusters.
Feeds the Unwrapped viz (group-by-pack vs audio-cluster as a story lens) and
vibe-search scoping. Never lets a pack boundary bias the audio analysis — it's a
hint to compare against, never a law.

CLAUDE.md blog-archival rule: commit messages + task logs are blog source
material. This adds the *narrative* layer above the terse armada/tasks/ log —
the documentary 'what happened / what surprised us / what we learned.'

01 tells the emotion-engine story: building CLAP synonym-cluster emotion reads,
the surprise that a 22%% score hid a *systematic* warm-positive center-pull
('playful' fired for 18/60 tracks), and the affine-calibration fix that named
the bias (valence +0.25 too warm, arousal compressed 1.7x) and corrected it
under leave-one-out CV. Includes the n=5 stem-vs-mix call PLN refused to
conclude on — honesty over a clean win.

#91 batch finished — all 60 famous tracks fetched + whole-mix analyzed.
First honest baseline on the full corpus (was n=5 before):

  top-1 emotion hit : 22%   (47% w/ overlap)
  V/A quadrant hit  : 42%
  mean V/A error    : 0.573

The center-compression hypothesis is confirmed at scale: 'playful' is the
predicted top emotion for ~18 of 60 tracks (Fleetwood, Marvin, Coltrane,
Avicii, Journey, Eminem...) because the distribution-weighted mean of the
circumplex anchors collapses toward the warm-positive centre.

Affine de-compression (gt ≈ a·pred + b, leave-one-out CV) learns exactly
that bias and corrects it:
  valence:  ×1.03  −0.25   (reads +0.25 too WARM — the playful pull)
  arousal:  ×1.70  −0.39   (compressed ~1.7x — needs the most stretch)
  LOO V/A err 0.573 → 0.519,  quad 42% → 50%.  Modest but real & cross-validated.

calibrate.py now writes per-mode files (calibration.whole-mix.json /
calibration.stem.json) so the #92 whole-mix-vs-stem decision can compare both
without one clobbering the other; calibration.json mirrors the freshest fit.

Stem-aware batch (demucs, all 60) launched in background to settle #92 on the
full corpus, not the n=5 that PLN rightly refused to conclude on.

New armada/tasks/completed-archive.md — per-task entries with description/done/learnings/
deps + commit hashes, richer than board-archive.md's terse snapshot, written as blog/video
source material. Seeded with this session's completed tasks: #65 (serve.py broken-pipe fix,
d70c3ee7 — keystone audition QOL) and #64 (Information-is-Beautiful dataviz epic + its
craft learnings). Appended by the /pre-compact ritual before clearing the board.

MidiStream fans one aseqdump subprocess out to N web subscribers (SSE), reusing
midimon.parse_line + enrich (one parsing source of truth); reader runs only
while watched (lazy start / stop on last unsubscribe, so no MIDI port held idle).
parse_ports is pure + tested. NOT yet wired into server/UI — see resume task.

Parked mid-feature: server SSE endpoint + dashboard panel still to do.

Clicking L'Armada served armada/ root → a file listing (felt broken). Point it
at armada/tide-table (where the viz lives) and open /triangle.html — same as
`tide.py serve`. Verified: /triangle.html → 200.

Also lands midimon.enrich() (note/velocity/controller→structured) + tests, the
parsing groundwork for the live MIDI dashboard panel.

The hub was dead links (clicking Foundry 404'd — its server wasn't running).
Now it's a real control center, with one shared registry driving both faces.

- launchers.py: allow-listed registry. Web tools (Foundry/Armada) = start-or-open
  via port-check (spawn the server if down, then open); native apps
  (Pulsar/Ardour/qjackctl) launch detached with running + availability state.
  Wayland has no portable focus → running apps report 'already-running'.
- midimon.py: 'aseqdump | tr' done right — parses each event, renders aligned &
  colourised with note names (C4) and velocity bars. parse_line is pure/tested.
- Bridge UI: hub shows live running dots; start-or-open opens a blank tab within
  the click gesture then navigates once the server binds (no popup block).
- perf-tray: 'Open Bridge' + 'Launch ▸' submenu off the SAME launchers.py — the
  tray is now the unified ParVagues tray (DRY with the web hub).
- 17 tests (launcher registry/state + MIDI parser). Verified: Foundry card boots
  the server → :8765 200.

So 'parvagues' is findable in the KDE app menu (the Bridge runs headless as a
systemd service → had no .desktop, nothing to index). Entry opens the dashboard;
ParVagues two-tone wave SVG as the icon. Installed via symlink into
~/.local/share/applications + kbuildsycoca.

Corpus 22→60 tracks, all 4 V/A quadrants now ≥13 (was +-:4, --:2 thin), 50 genres,
all 12 emotions — chosen for confident, balanced priors (quality of pseudo-GT > raw
count for calibration). Added the sad/dark-calm + calm/pleasant fillers (Portishead,
Mazzy Star, Satie, Debussy, Coltrane, Bon Iver…) the gaps report flagged.

emotion_calibrate.py: fits per-axis affine gt≈a·pred+b over analyzed∩GT to DE-COMPRESS
the center-biased CLAP read (learns the scale-up from data, not a guessed tau).
Reports leave-one-out CV error (honest generalization, not in-sample) + re-derives the
label from calibrated V/A (nearest anchor) so we see if labels improve too. Pragmatic
call: scale corpus = whole-mix analysis (demucs doesn't scale to 100s/1k; stems didn't
beat mix on accuracy) — stems reserved for the hexa lane.

- perf-tray.py drops its duplicated Thermals/detect_mode/_read*/MODES/SCRIPT
  and imports them from tools/bridge/perf.py — the tray is now just the Qt face
  of the same logic the web Bridge serves (one source of truth)
- tray icon restyled with the ParVagues signature wave (drawn in Qt, no asset)
  under the heat-coloured temp badge
- parvagues-bridge.service → WantedBy=default.target so it boots headless with
  linger (always-on dashboard, no login needed); tray stays graphical-session
- deployed: bridge enabled+active on :8773, tray restarted, linger enabled

PLN's validation idea: famous tracks whose feeling/structure/genre the model already
knows = pseudo-ground-truth to grade the emotion engine, disagreements driving tuning +
coverage (self-correcting 30→100→300). emotion_corpus_gt.json: wave-1 22 tracks spanning
all 12 emotions + V/A quadrants + genres + structural archetypes (steady / quiet-loud /
long-build); GT = emotion labels + V/A centre + approx fractional section structure +
genre. emotion_corpus.py: fetch (yt-dlp android+bestaudio 403 workaround) → analyze
(demucs+stem-aware or --mix) → grade (emotion-hit, V/A error, quadrant, vocal-presence) →
gaps (coverage histogram → next wave).

BASELINE (whole-mix, 5 tracks): 40% emotion-hit, 40% quadrant-hit, mean V/A err 0.75 —
honest verdict: NOT yet trustworthy. Three systematic biases surfaced: (1) center/positive
compression (extremes pulled to mild +V/+A), (2) 'playful' over-fires (3/5), (3) whole-mix
misses aggression entirely (Prodigy Firestarter→playful +V) — the exact case stem-aware
(drums/bass arousal) should fix. Corpus now drives calibration before the #90 hexa handoff.
gaps: +- and -- quadrants thin, fill at wave 30.

Adds analyze_stems(): separates via foundry_stems (vocals/bass/drums/other), scores
each stem on a shared window grid, fuses V/A by stem role (valence rides vocals+other,
arousal rides drums+bass+mix), and flags vocal presence per window as a structure cue.
Refactor: shared _finalize (smooth→relabel→section→summary) now serves both whole-mix
analyze() and analyze_stems(); embed_at/window_grid/windows helpers extracted.

FINDING (Bohemian Rhapsody, mix vs 4-stem): stem-aware gives a cleaner valence track +
vocal-presence sections (88% vocal; outro correctly reads calm, not 'cold'), BUT the
current arousal fusion UNDER-weights the mix and softened the hard-rock peak that the
whole-mix caught (tense A+0.77 → hypnotic A+0.55) — that section's intensity is a
full-mix gestalt isolated stems lose. So fusion weights need empirical tuning; the
ground-truth corpus (next) drives it. Both modes run end-to-end (#89).

Answers 'is there a ParVagues web service running a dashboard?' — now yes.
Folds perf-tray's function into a web toolbar + extensible fleet hub.

- perf.py: rootless Thermals (hwmon) + detect_mode + sudo-backed set_mode,
  ported from perf-tray.py with Qt dropped (DRY-able with the tray later)
- server.py: stdlib http.server (Foundry lineage); GET/POST /api/perf, /api/hub.
  Binds 127.0.0.1 by default — mode-switch flips the CPU governor via sudo, so
  not LAN-triggerable unless --host 0.0.0.0
- ui/index.html: Ship's Bridge toolbar (live temp badge 55/70/85, mode switch,
  freq/fan/throttle) + hub cards (Foundry :8765, Armada :8731)
- bridge.py CLI (serve/status/perf); parvagues-bridge.service (systemd --user)
- 6 tests on pure perf logic; README incl. deploy + security notes

Smoke-tested: tests green, API live, mode detect + thermals reading correctly.

Stem-aware emotion needs the voice isolated: the full mix is muddy for CLAP, but
the VOCALS carry valence, DRUMS+BASS carry arousal, and vocal presence is itself a
section/structure cue. ensure_stems(file, slug) consumes the Foundry's in-process
Python API (tools/foundry, the shared separation engine) → {mix,vocals,bass,drums,
other} absolute paths, idempotent via catch.json (re-runs free). Validated: 4-stem
demucs separation of a 6-min track (Bohemian Rhapsody) lands all four stems clean.
Feeds emotion_timeline's stem-aware analysis (#89) and the hexa lane (#90).

- README: 'Use as an API' — Python import / CLI subprocess / HTTP API, the
  path+catch.json contract, env overrides (for sibling tools e.g. the #89
  emotional-arc tool that consumes the demucs engine for stems)
- README: add 'link' to CLI reference
- research/{A,B,C}_*.md: the three strand reports (empirical profile,
  fundamentals rulebook, prior-art + recommended zero-dep stack)
- research/PHASE2_FINDINGS.md: strand-D synthesis — corrected per-stem model
  (loops cut per stem, often-but-not-always time-aligned), loopability rubric,
  Take/StemSlice model, correlation engine (§5·0 GT-at-scale), Hall of Fame
  tierlist, section-label grounding (↔ #89), 80/20 build order
- PHASE2_LOOPFINDER.md charter: grounded in the real flow + ground-truth pairs

Windows a master (~12s/50% hop), CLAP-embeds each window (new sample_semantics.
embed_audio_arrays seam), runs the emotion_ontology kernel per window → (valence,
arousal, top-emotion) series; median-smooths, relabels from the smoothed circumplex
point, fuses short runs into emotion SECTIONS. Emits frames+sections+summary JSON —
the continuous-V/A + discrete-scene lane hexa wants. Validated on Bohemian Rhapsody:
caught the warm-intro → energetic-middle → tense rock-peak (A+0.77) → calm-outro arc.

Each emotion is a CLUSTER of angle prompts (adjective pairs + scene metaphors +
bodily framings, EN+FR) marginalized to one robust per-emotion score (mean cosine,
size-invariant) — the synonym→emotion fold mirrors the resolver's descriptor→family.
12 emotions × 6 angles, each placed on Russell's valence/arousal circumplex, so the
distribution yields a continuous V/A point + a discrete top-emotion label.

Per-window kernel: score(ae_row) takes one CLAP audio embed → {scores, dist, top,
valence, arousal, confidence}. Validated: probe archetypes land correctly (melancholic
0.76, aggressive 0.94, hypnotic 0.94, cold 0.72); real-audio path confirmed (pad→
dreamy/melancholic calm). Feeds the planned per-track emotion timeline (hexa lane).

- engine/publish.py: link_kit() symlinks Samples/<kit> → Dirt-Samples/<kit>
  so a freshly-cut kit loads as s "<kit>" (325/508 Dirt-Samples entries are
  this pattern). Idempotent; repoints stale links; refuses to clobber real dirs.
- foundry.py link <kit> CLI; 5 new tests (15 total, all green)
- PHASE2_LOOPFINDER.md: research charter for the loop-finder (Sonnet-agent
  deep-research pass) — grounded in the REAL flow (yt → separated/htdemucs →
  hand-cut → Work/Sound/Samples → ln → Dirt-Samples → .tidal), with the
  crimewave/diams_dj/humpty stem→loop pairs as free ground truth
- README: export target corrected to Work/Sound/Samples + link step

The Sample Foundry: turns a track URL into separated stems ready for
sampling, replacing the manual yt-dlp → demucs → Audacity dance.

- engine/ — pure-ish, importable steps (model/fetch/separate); heavy work
  shells out to dedicated venvs so the engine runs under system python3
- separate.py = pluggable backend REGISTRY: demucs (engine1, live) +
  roformer (engine2, stubbed) behind one --backend interface
- foundry.py — CLI driver (fetch/sep/catch/list/backends/serve), tide.py-style
- server.py — stdlib GUI backend with job-progress + HTTP Range (audio seek)
- ui/index.html — self-contained GUI in the armada Ship's Bridge tokens;
  stems colour-coded by role (bass/drums/other/vocals)
- tests/ — 10 unit tests on the pure parts (slug, info-parse, argv, registry)
- README — workflow, engine1→engine2 roadmap incl. Roformer hyperparams +
  6GB VRAM caveat, phase-2 loop-finder charter, UX surface

Validated end-to-end on the Loituma test catch.

copyfile() threw BrokenPipeError/ConnectionResetError (Errno 104) when a
browser aborts/seeks a Range request mid-stream — normal for <audio>
scrubbing, but it spammed a traceback. Wrap both copy branches and close
the file handle in a finally. Verified: mid-stream abort leaves no
traceback and the server keeps serving (206 follow-up OK).

Adds the edit/remaster/pull/permanence axis the cost model was missing:

- 4th cost bucket UPDATE: re-mastering an already-live release. Free on
  RouteNote; a new paid release on CD Baby; forces DistroKid to the Ultimate
  tier ($89.99/yr) for an in-place Audio Swap. Driven by a Remasters/year slider.
- Freedom & control matrix: per-option remaster / edit-metadata / takedown /
  if-you-stop-paying, glyph+text+colour (never hue alone). Surfaces the key fact
  that no DSP distributor swaps audio in place (a store rule), with Bandcamp the
  free-replace outlier.
- Ownership reframed: all options are non-exclusive (you keep 100% of masters);
  what differs is permanence, edit-freedom, portability.
- Softened the unverified RouteNote freeze-risk claim; flagged Premium pricing
  as contested pending verification.

Both --extreme and --optimize disabled intel_pstate turbo on the theory
that frequency changes cause jitter. On HWP-capable CPUs (i7-10875H) the
performance governor already holds clocks steady at the top; disabling
turbo only caps all cores at the 2.3GHz base (~64% of clock headroom
thrown away), starving SuperDirt's DSP and causing the very xruns/crackle
it was meant to prevent. Now pins min/max_perf_pct=100 with turbo on.

Snapshot resolved tasks (foundation/distro, Ardour/boundaries, Judge UI, triangle
DRY, fleet colour, the sample-grounding fun-sprint, and the dataviz epic #64) so
the active board stays lean. Active board now = pending/in-progress only.

Field: per-cell DOMINANT family colour (was a mean of all overlapping hues →
brown mud); mixed/overlap zones now fade by 'purity' instead of muddying.
Tuned colourful-but-subtle behind the dots (desaturate 0.40 + slight lift to
white, maxα 0.44) — dots stay the stars.
Zoom/pan: wheel to zoom at cursor, drag to pan when zoomed, +/−/reset controls
(top-left) + double-click reset; dots grow with zoom; field & hit-testing follow
the view transform, clipped to the plot rect.

sample_families.json was built at a smaller per-folder cap → only 831 per-index
entries (825 of the 1485 plotted samples labelled). Re-ran the resolver at
--max-files 12 (same clap:fine method) over 150 folders → 1501 per-index entries,
1490 labelled. unwrapped.json now 100% family-coloured (was ~56%): no more grey
'unlabelled' dots, the density field reads everywhere.

Low-res IDW of dot colours (72x46 Gaussian-weighted, σ≈3.1), desaturated 50% and
faded by local density, bilinear-upscaled behind the dots → pink kick region,
blue keys region, purple bass / yellow hat pockets emerge as a slow gradient.
Cached offscreen, rebuilt only when colours/axes/filter change (never on hover);
'regions' toggle in the controls; auto-off in vibe-search mode.

Loading weights wasn't enough — the first forward still cost ~30s on torch's
one-time graph/thread init. Warm now runs a throwaway _embed_texts() so the first
USER query is ~1.5s, not 30s.

The first /vibe hit cold-loaded CLAP (~16s) with the UI stuck on 'searching…',
reading as hung. Now serve.py warms the model in a daemon thread at startup (when
semantics_embeds.npz is present) so the first query is instant; the client shows
'first search loads the model, ~15s' on a cold start and aborts after 90s with a
retry hint instead of spinning forever.

index.html ties the corpus dataviz together (By the numbers · Unwrapped · The
Triangle) and opens with a typographic style cloud sized by TRACK count — read
from PLN's own gig metadata (catalog_view metas[].style via models.norm_style),
never per-sample CLAP genre. dnb 18 · breaks 17 · techno 14 · nujazz 12 = the
TechnoJazz spine. build_landing.py bakes landing.json (cloud + corpus stats).
Ship's Bridge; magenta only on the live-dot + cloud hover.

- build_unwrapped: 2D PCA of the CLAP embeds → per-sample 'vibe map' coords +
  16 seed-vibe chips (PLN's own words — the on-ramp, since users don't know what
  to type). vibe0/vibe1 join the axis picker as a semantic-space lens.
- unwrapped.html: VIBE SEARCH box (free text → /vibe) + clickable seed chips;
  results highlight on the map (dim misses, size hits by similarity, ring the top,
  faint-violet→magenta ramp) and auto-reveal the vibe map; result strip auditions.
  Shift-click any dot → /similar (nearest neighbours in embedding space). Null-safe
  plotting for vibe/raw axes. Graceful banner when the endpoint is absent.