Two errors stacked in one metric, both found by looking at its distribution instead
of its verdicts.

**It penalised short loops for being short.** Autocorrelation at lag k has only N-k
overlapping frames, but the score was normalised by ac[0], which sums all N — so the
number was partly a function of how much of the loop the lag consumed, and a 1-bar lag
consumes half a 2-bar loop against an eighth of an 8-bar one. On a perfectly periodic
click track the biased estimator reports 0.418 / 0.623 / 0.754 at 2 / 4 / 8 bars for
IDENTICAL material. Dividing by the per-lag overlap count first: 0.834 / 0.830 / 0.862,
flat as it must be. Corpus medians moved 0.12 -> 0.24 (2 bar), 0.31 -> 0.41, 0.43 -> 0.49.

**And then it asked every role the same question.** Split by family across 81 bar-loops:
drums 0.754, fx 0.549, tonal 0.214, bass 0.173, vox 0.087 — an 8.7x spread end to end.
A drum loop that does not repeat at the bar is broken. A sung phrase that does not repeat
within itself is a sung phrase, and a held chord is a perfectly good loop with no onset
period at all. One threshold across all of them condemned 12 of 20 vocal loops for the
crime of being vocal. Floors are now per family, and vox is measured-but-never-flagged.

Also: dead bars are now rejected at EXPORT rather than reported afterwards. A 4-bar loop
whose last two bars are a fade grades S — silent-to-silent is a perfect seam and the
length is still an exact bar multiple — and 10 of the first 161 cuts were exactly that.
An objective defect with an objective test belongs in the gate, not in a report someone
has to read.

First full run for the record: 161 samples, 43 kits, ZERO bar-length errors and 161 of
161 distinct sounds, so the bar-multiple guarantee and the export dedup both hold at
scale. 21 tests in this file, 104 in the suite.

Two ways to be wrong about a stem, pulling opposite directions. Plus the README
section for stempack/kitcheck and the thresholds, all picked from measured data.

librosa's peak-picker finds peaks in whatever onset envelope it is handed, flat ones
included: a steady 50 Hz sine yields 84 onsets over six seconds (14/s) and was being
filed as drums, which made the bass branch unreachable for exactly the signal it was
written for. Onset count is now gated on the frame-RMS crest — ~1.0 for a sustained
tone against 3.1-9.5 for anything struck.

Measured across MAREA/ANGIE/ME to pick the threshold rather than guess it. Worth
recording that crest is a SPARSITY measure, not a percussion one — MAREA's single
vocal phrase reads 17.98 — so it only ever gates onset density and is never used
alone. HPSS was tried first and rejected: a kick-heavy drum bus reads 0.094
percussive, because HPSS hears a modern kick as harmonic.

18 tests.

Three separate errors, each of which quietly threw away good material.

**Where it looked.** Evenly-spaced probe windows sample the gaps. A stem is not
stationary — measured on ANGIE, even windows read HIHATS at -60.9 dBFS / 1.4%
active where the full file says -48.8 / 9.7%, and missed PAD STUFF's material
entirely (0.0% vs 6.9%) because that stem only plays in two sections. Windows are
now ranked by energy and chosen where the stem is actually playing.

**What it measured.** Usability was gated on overall RMS, which on a sparse stem
measures how much silence it contains, not whether it has material in it. ANGIE's
HIHATS stem is -48.8 dBFS RMS and a perfectly good hi-hat stem peaking at -14.7.
Level and activity now come from the whole file (it is only a frame-RMS pass) and
the gate is peak plus activity relative to the stem's own peak. Three ANGIE stems
and two MAREA stems come back from the dead.

**What it concluded.** "Mostly low energy, low centroid ⇒ bass" fires on a drum bus,
because a modern kick carries most of a drum mix's energy: ALL DRUMS reads lf 0.86,
centroid 216 Hz, indistinguishable from BASS on those features. So ALL DRUMS was
being filed into the bass kit AND mono-summed, and KICK with it. Onset density is
asked first now (ALL DRUMS 5.5/s vs BASS 1.1/s), and a `hits` claim survives a bass
measurement, because a kick IS low and slow and only the label says it is one hit.

And the authority question underneath all of it. The house rule is that a sound's
role is never INFERRED from its name; it is not that a producer's label about their
own stem is worthless. Those have very different evidential weight. Presence and
bass are decided by measurement — a stem under -40 dBFS peak has nothing in it, and
"all energy under 150 Hz, nothing above 2 kHz" is unambiguous. Everything else keeps
the label, because onset density cannot separate a rhythmic rhodes from a drum bus:
MAREA's KEYS2 reads 5.1 onsets/s and its sparse CLAP reads 1.0, so measurement alone
files both in the wrong kit, silently. Disagreements are reported, not resolved.

Also: register_fred_rights.py records a freshly cut third-party kit in the rights
ledger as third_party WITH its provenance, at the moment of cutting. Left alone it
would land as `unknown` at the next --init, which blocks correctly but blocks with
no reason attached.

All three found by running the thing, not by reading it.

**Chops beat loops mechanically, every time.** grade classes anything under 0.75 s
a one-shot and scores it 0.5*level + 0.3*dc + 0.2*zc -- no seam term, no bar term,
because a one-shot is never looped. Export already removes DC and snaps zero
crossings, so a chop lands near 1.0 by construction, while a loop pays 0.35 on seam
and 0.25 on bar consistency and rarely maxes both. Measured on ME: every chop
0.993-0.999 (S), every loop 0.841-0.881 (A). Ranked head to head the vocal kit came
out as three stabs and no loops -- exactly backwards from what was asked for. Modes
now rank in separate pools with their own slots.

**Every loop got its own tempo.** analyze_stem reports a candidate's bpm as the mean
local BPM inside its own window, which is the right number for detecting drift and
the wrong one to derive a bar length from. ME's track grid read 129.2 bpm while both
shipped loops were cut at 150.5 -- so two loops from one track do not layer, and
loopAt lies. Bar length now comes from a single robust track tempo: the MODE of the
local-BPM histogram, not the mean, because a few dropped or doubled beats drag a mean
and leave a mode alone. Validated on a synthetic 120 bpm pack: 120.2, 0.2% off.

Confidence comes with it -- the share of beats within 5% of that tempo. Below 35%
there is no pulse worth cutting bars against and the track ships chops only. ME is
the case that motivated it: no drum stem at all, so the grid was derived from a
texture stem that merely measured percussive.

**Near-duplicates were shipping.** A producer pack overlaps stems on purpose; ALL
DRUMS, KIT, MAIN DRUM LOOP and DRUM BREAKS are four views of one groove and the
finder picks the same bar out of all four. Eight slots holding three sounds is a
worse kit than three. Dedup now runs at export, reusing kitcheck's mel fingerprint
and its threshold so the auditor and the exporter cannot disagree about what "the
same sound" means. Smoke test: 12 cuts -> 7, 6 of them distinct.

Also: the merged report regenerates from the merged cuts instead of concatenating
the children's fragments, which froze the tables before CLAP tagging ran and lost
every tag; and kit_multiples_check no longer runs over chops, which are sub-bar by
definition and were producing an off-grid warning that meant nothing.

101 tests green.

The Foundry could make stems (yt-dlp → demucs) but not eat stems somebody else
already made. Fred again's dropbox is 9 tracks × 6-13 producer-labelled stems at
96 kHz/24-bit — better source material than demucs can produce, and completely
outside what find_takes accepts: it keys stems by drums/bass/other/vocals, a dict
that collides on KEYS1+KEYS2 and an export keep= filter that would have silently
dropped every stem in the pack.

engine/stempack.py is the missing batch driver (TODO #20), and building it turned
up a real bug. MAREA ships its tempo in the filename (…123BPM…), so it is free
ground truth. At native 96 kHz the finder returned 123/123/124/119/128.1/128.5 bpm
and a 0.661 top score; resampled to 44.1 kHz first it returned 123.0-123.1 on every
candidate and 0.859, in a third of the time. librosa's hop/window defaults are
sample-rate-relative, so at 96 k every analysis frame spans half the musical time
and beat tracking wanders. Rate is a correctness input, not a performance knob.

engine/roles.py maps the pack's ~40 role tokens (39/40 hit directly) to a family,
then verifies the label by measurement before anything trusts it — the house rule
that a sound's role is never read off its name. The `hits` family
(KICK, SNARE alone) is the one place the label carries information the cheap features cannot: an isolated kick
and a full groove measure identically.

engine/kitcheck.py audits what grade.py cannot see by construction. A four-bar loop
whose last two bars are a fade grades S — silent-to-silent is a perfect seam and the
length is still exact. So: per-bar RMS for dead bars, onset-envelope autocorrelation
for whether a bar-aligned window is actually a repeating unit, and mel-fingerprint
cross-correlation for near-duplicates, because a pack shipping ALL DRUMS + KIT +
MAIN DRUM LOOP + DRUM BREAKS will otherwise ship one groove four times.

--jobs fans out as subprocesses, not a ProcessPoolExecutor: the pool's forkserver is
broken under this Python (BrokenProcessPool on a trivial task), and one process per
track also means a track that blows up loses only itself.

15 new tests.

Captain's log for the SoundCloud uploader landing. Written for the documentary
rather than the board: the story beat is that I spent a session and a half
picking a window on `POST /tracks` — killing three hypotheses one at a time,
each death feeling like progress — while a real, logged-in, past-the-wall
browser sat open with the actual upload form in it.

Also records the two catches that were PLN's, not mine: the chip-input tags, and
the MUI Select whose Private option my four probes all reported as absent.

Session of 2026-08-17/18 written back to the board for a cold reader, since the
Task API is still unreachable from this session and the scratchpad — which held
the release plan and every log — was cleaned mid-session. (The plan regenerates
from canonical sources, which is exactly why it is a generated artifact; it now
lands in Prod/Opal26_master/release/ rather than /tmp.)

A3 rewritten: the SoundCloud uploader WORKS. `POST /tracks` never needed solving
— it was the wrong door. Recorded the account's verified state (8 of 15 up, all
private, including the 72:41 mix), the two DOM facts that cost a session each,
and two defects a re-run will NOT fix by itself: take-five-drops uploaded 24 s
short, and ghosts-in-the-toilets carries one malformed tag from before the
chip-input fix. Also recorded that api-v2 is a dead end for BOTH create and
update, so nobody re-opens it.

A5: the YouTube adapter is built, with the finding that decides its architecture
— the Data API cannot publish at all from an unaudited project.

New EPIC G (Slopmotion release videos) carries the renderer's two landed fixes
with their measurements, the one modal still blocking, and the 50-commit pull
that inverted the app's mode semantics under us.

New EPIC H is what PLN asked for: the long-term setup plan split into PRE-GIG
(what must be true before playing again — the 59%-audible kick, orphan orbits,
preload staleness, SC supervision, the LCXL v3) and POST-GIG (the release
pipeline). Plus H3, the standing lesson: three confident conclusions this session
were wrong the same way — a blind instrument reported absence — and PLN's own
eyes beat the probes every time.

The 19 bake-off clips all shipped with the photosensitivity warning sitting on
top of the visuals. PLN: "lol all clips have the epilepsy warning on top of the
viz xD and all seem to have very low fps, like maybe 5 ?"

Extracting a frame showed one cause behind all three symptoms: the warning modal
itself; the app's full UI chrome still visible (FX rail, top bar, shortcut strip)
because the modal swallowed the "minimal performance shell" click and the `h`
keypress; and the apparent ~5 fps, because ~90% of every frame was static chrome
behind a dark scrim while 17.6 frames/s were captured faithfully. The frame rate
was never the problem — I had measured it correctly and drawn the wrong picture
of what was being measured.

Seeding localStorage does NOT suppress it: hexa installs a dev-only bridge that
persists localStorage to disk through the dev server and calls
`hydrateLocalStorageFromDisk()` at boot, overwriting anything an init script
seeded. Verified by trapping `Storage.prototype.setItem` and reading the stack —
the write came from `localStorageBridge.ts:150`. So use the app's own control:
uncheck "Show this warning at startup", click OK, which writes through the bridge
and flushes to disk.

PARTIAL, deliberately. The new guard now throws rather than capturing, and on the
next run it caught a SECOND modal behind the first: "START A SESSION". So the
bake-off clips were not slow — the scene had never started. Committing the guard
alone because it is strictly better than silently shipping 19 more scrims, and
refusing loudly is the behaviour worth having even before the fix is complete.

Still to do (see the task board): a `git pull` brought 50 commits that also
inverted the mode semantics — `?studio=1` is now stripped and Studio is the
DEFAULT, with `?live=1` opting into the full-bleed performance shell; Studio
freezes shader time when `studioTransportActive === false`, which is the other
half of "no motion"; and the "Minimal performance shell" button this script
clicks no longer exists at all.

Every SoundCloud blocker this week fell to looking at the page instead of
reasoning about it, so the probes are kept rather than thrown away — each one
encodes a question worth re-asking when SoundCloud changes its uploader again.

  * `probe_upload_form.py` — enumerate every input/select/textarea/button in the
    upload frame with its label. This produced the whole selector table the
    uploader is written against: #title, #trackPermalink, #artist, #primaryGenre,
    #tags, textarea#description, input#fileInput, and the Upload button.
  * `probe_upload_privacy.py` — read the radio groups properly. Answer: they are
    geo (worldwide/exclusiveRegions/blockedRegions) and licensing
    (all-rights-reserved/commons). NOT privacy.
  * `probe_upload_legacy.py` — does an older, non-v2 uploader still exist with a
    Public/Private choice? Written when I wrongly believed the v2 form had none.
  * `probe_upload_watch.py` — open the real form and poll for state changes, so
    PLN can click a control and have the script report exactly which element it
    is. Built after concluding, twice, that a control was absent.
  * `probe_upload_sharing.py` — drive the MUI Select and VERIFY the trigger
    changed. Confirms Public -> Private end to end.

The lesson the set exists to encode: I reported "the v2 uploader is public-only"
after sweeping every input, select and radio in the frame and finding nothing.
The control was a MUI Select, whose options are portal-rendered only once the
trigger is clicked — so an unmounted menu and an absent feature are
indistinguishable to a DOM sweep. PLN pasted the real markup
(`li[role=option][data-value="Private"]`) and it drove fine first try. A
component library's Select is not `<select>`, and "I searched and found nothing"
is a statement about the search.

Correcting my own previous commit, which concluded hardware GL required headful
and made `--gl hw` open a real window per clip. PLN, mid-batch: "stop opening
chrome windows lol cant we do this headless". Yes — and the conclusion was wrong
because I tested three launch modes and stopped at the first that worked.

Five headless modes plus headful, each asked what WebGL actually resolved to:

    --use-angle=swiftshader                       -> SwiftShader (Subzero)
    --use-gl=egl                                  -> SwiftShader (Subzero)
    --use-angle=vulkan                            -> SwiftShader (Subzero)
    --ozone-platform=headless --use-angle=vulkan  -> SwiftShader (Subzero)
    --use-gl=angle --use-angle=gl-egl             -> Mesa Intel UHD (CML GT2)
    HEADFUL                                       -> Mesa Intel UHD (CML GT2)

`--use-gl=angle --use-angle=gl-egl` reaches the real GPU with no window at all.
It is ONE FLAG WORD from `--use-gl=egl`, which silently degrades to software —
which is exactly why the original code read as correct and was not, and why the
comment claiming the hw path "falls back by simply measuring worse" survived so
long. It never fell back: 3.5 fps and 3.2 fps were the same software backend
measured twice, and two numbers that looked like measurement noise were one wrong
assumption.

Measured, landscape 1920x1080, same 30 s window each time:

    swiftshader (headless)   3.5 fps captured
    headful + real GPU      11.4 fps captured, page rendered 17
    headless + gl-egl       17.8 fps captured, page rendered 542 of 542

Headless is FASTER than headful — no compositor in the path — and the capture
bottleneck disappears with it: captured frames now equal rendered frames, where
headful drained 346 of 516. So the earlier "the next lever is the capture path"
note was also an artefact of the wrong launch mode. 5x the software baseline,
comfortably past the under-5-fps guard, and no windows.

Lesson for the file: an early success is not a search. Two of the five modes
reach the GPU and three do not, and the three failures are indistinguishable
from each other by frame rate alone.

Every bake-off render failed, for two independent reasons, and the second one had
been sitting in this file as a comment asserting the opposite of the truth.

## 1. The playwright browser cache is empty now

`chromeBinary()` scans `~/.cache/ms-playwright` for a full chromium build and
returns `undefined` if it finds none, on the documented theory that this "lets
playwright pick". It does not. Playwright reaches for the exact build it shipped
against — `chromium_headless_shell-1234` — which was never downloaded, so every
render died with "Executable doesn't exist" before rendering a frame. The cache
directory is now absent entirely (it held build 1217 back in July). Falls back to
`/usr/bin/chromium`: a full build, already driven by the SoundCloud transport, and
no ~150 MB pull into PLN's shared cache behind his back.

## 2. `--gl hw` never got hardware GL

The old comment claimed swiftshader manages ~7 fps and that `--gl hw` "asks for
the real integrated GPU via EGL. Falls back by simply measuring worse." It was
not falling back — it never left software. Instead of inferring the backend from
frame rate on a machine whose load is a variable, I asked WebGL what it resolved
to:

    headless + --use-angle=swiftshader -> SwiftShader (Subzero)
    headless + --use-gl=egl            -> SwiftShader (Subzero)   <- identical
    HEADFUL                            -> Mesa Intel UHD (CML GT2)

Headless cannot reach this box's GPU whatever the flag. Which explains the
symptom exactly: landscape 1920x1080 captured 3.5 fps on swiftshader and 3.2 fps
on "hw", tripping the renderer's own under-5-fps guard both times — two numbers
that look like noise and were actually the same backend twice.

`--gl hw` now means HEADFUL. Measured after: **11.4 fps captured, page rendering
17** — 3.3x, comfortably past the guard. Note the bottleneck has moved: the page
now renders faster than the CDP screencast drains, so the next lever is the
capture path (frame encoding), not the GPU. Cost is a visible window for the
duration of each capture.

The July note warned against trusting those fps follow-ups because they were
measured at load average 12.5, and it was right to. But the fix was not a quieter
benchmark — it was asking a question that load cannot corrupt. Third time this
month a "the rig is broken" finding turned out to be the instrument.

PLN: "dont render 2h for now lol render 20x different presets 30s clips then let
me watch/listen/grade through. try to do sth gtreat soundreactive". Right call —
19 clips of 30 s is ~10 minutes of realtime capture against 2h25m for the record,
so the taste decision gets made on cheap evidence.

Also recorded: "slopmotion gave me rights to all packs, we can use any, lets be
free and test stuf". Every local pack is fair game, which is worth writing down
precisely because it is the opposite of the sample-bank situation next door.

## Experiment design

Every clip renders the SAME 30 s window. With the audio fixed, the only variable
is the look, so the grades mean something; vary two things and a favourite tells
you nothing about why. 18 packs get one clip each at one reactive baseline, and
clip 19 is `parvagues` again with reactivity OFF. That control earns its slot —
"do something great soundreactive" is unanswerable from 19 all-reactive clips,
because nothing shows what the reactivity contributes. parvagues sorts first as
PLN's own imagery; the control sorts last so it is graded next to its twin.

The reactive baseline is four FX chosen to read differently on a transient —
glitch and rgbDelay snap, liquix flows, slowmo pulls time — since under
`--triggerHeavy` each becomes kick-synced. Four subtle washes would hide the
exact thing being evaluated.

## The window, and a metric that was measuring the wrong thing

Reactivity feeds on onsets, so I scored 30 s windows by summed positive spectral
flux normalised by level. It picked 69:18 at -23.3 dB — the near-silent seam
between Vague de CRIME and REVOLUTION, i.e. PLN's 2 s rest plus a reverb tail.
Dividing by the window mean rewards silence: a quiet window with any activity at
all beats a loud groove. Using the level-gated answer instead — 1:34, -10.1 dB,
inside the techno opener, four-on-the-floor — which is the honest test for
kick-synced triggers. Same shape as ranking orbits by level instead of punch.

Two preflight checks that exist because of what they would have cost: a pack
needs BOTH local loops and a `videoLibrary.json` row (the renderer picks its
backdrop from the library, so a pack with 30 files and no row fails at clip 12,
after eleven realtime renders), and dead symlinks into Kevin's own machine are
skipped rather than attempted.

The grading page follows judge.html and bounds.html: local, not an Artifact,
because 20 clips is hundreds of megabytes and the viewer sandbox blocks a
page-initiated download — and the grades have to come back as a file.

I had `master yt render` wrap each track in a still image, and picked that still
from `output/*.jpg`. PLN: "i dont like these covers, wait where are tehse genai
images from? these are not great sources! we wanna use slopmotion for videos
remember?" Both objections land, and the first is the one worth recording:

  * Those nine illustrations are UNTRACKED and have no recorded provenance.
    `6c3272c9 refactor: Remove covers from git` had deliberately taken covers out
    of this repo, so "sitting in output/" was evidence against using them, not
    for it. I built a per-bank rights ledger for the audio this same session —
    one that refuses a sample bank precisely because its origin is unrecorded —
    and then reached for pictures off the floor. The discipline has to apply to
    every asset in a release or it is not a discipline.
  * Slopmotion already does this properly, already supports `--shape landscape`
    at 1920x1080 explicitly "for YouTube", and has already produced a real
    7m26s landscape render. Nothing needed inventing.

So this bridges the release plan to `visuals/slop/render_slop_clip.mjs`, naming
its output exactly what `tidal_ears.yt.video_path` produces — imported from the
adapter rather than reimplemented, because two copies of a filename rule is how
a renderer and an uploader come to disagree about which file is track 7.

## Realtime is the whole scheduling story

Slopmotion captures in realtime by design: Hydra's clock is wall time, so
frame-stepping runs motion ~3x fast and drifts off the audio it reacts to. A
full-length render therefore costs the track's own duration. OPAL-26 measures
**2h25m** of headless Chromium for the landscape shape — 1h12m of continuous mix
plus 1h13m of tracks. Too long for a shell job that dies with its terminal, so
`--unit` writes a `systemd --user` service with `TimeoutStartSec=0`. Renders are
resumable, so an interruption costs one clip.

Preflight refuses before spending any of that: node >= 22 (system node is 16 and
fails), the dev server actually answering on :5173, every audio file present,
the playset known to the 24-pack catalog.

## The join that had to stay explicit

`clip_ideas.json` agrees with the release plan on neither axis. Its titles are
shorter or French ("Sunshine", "La Revolution Sera Samplee") and its
`setlist_pos` follows an EARLIER running order — its 4 is Take five Drops where
the plan's performance 4 is Am i Doing it Right. So position is not a join and
title equality only catches 4 of 6 live ideas. Fuzzy matching would be worse
than nothing: it puts a look on the wrong track silently. A two-entry alias
table takes it to 6 of 15; the other 9 report no playset and the tool refuses to
guess, because which visual goes with which track is PLN's call.

Two probes for the SoundCloud upload flow. `probe_upload_dom.py` is the one that
settled it: rather than hypothesise about why /upload showed no file input, it
dumps overlays and z-indexes, enumerates every frame, walks shadow roots, prints
the main region's text, and tries clicking whatever looks like a drop zone. The
answer arrived in one run — 0 file inputs in the top document, 1 in a nested
same-origin iframe at /n/upload.

`probe_upload_ui.py` now attaches in that frame and listens on the CONTEXT
rather than the page, because a frame's fetches never surface on the parent's
request event — the same blind spot in a second guise. It reached the real form:
inputs named title / trackPermalink / artist, plus an Upload button.

It captured zero finalize requests, and that is correct: it deliberately stops
short of clicking Upload, and the finalize call only fires on that click. Which
raises the better question — with a real form and a real Upload button in front
of us, reconstructing `POST /tracks` may be work we never have to do.

Writing for a cold reader, because the valuable part of this session is the
DEAD hypotheses and those live only in context.

POST /tracks -> 400 {"errors":[]} has now survived three explanations and each
one cost a real experiment: it is not fingerprinting (identical from curl_cffi
and from the page's own fetch), not the envelope ({"track":{…}} is the only
shape that parses at all — flat, track[…] form and asset_data are rejected with
"Failed to parse track create request"), and not the missing web session
(retested after PLN logged in for real; session_ok() True, still 400). Anyone
resuming would try those three first, so the board says not to.

The one lead left is the consent dialog covering the upload form — session_ok()
is True while input[type=file] count is 0 — so probe_upload_ui.py moves out of
the scratchpad and into the repo. It attaches a 1s probe to the REAL form and
logs every non-GET api-v2 request, which is how we stop reconstructing a shape
from publish.py's older API and start copying one that demonstrably works.

Also recorded: the multi-platform architecture PLN asked for (one manifest, many
adapters, one state file), with the research behind it — Bandcamp has no upload
API or CLI at all, RouteNote has no open API but ships a desktop tool, YouTube
has a real one and gets chapters free from segments_v4. And the gig-list audit:
38 gigs published, 2026 has four, opal-festival-2026.md still has empty
audio/video/archive fields waiting on the upload.

His verdicts, verbatim: "jungle breaks is a open domain cd, h2o is hydrogen oss
drum machine, kick risers are from the tidalcycles officials or samples-extra
cc0 packs, and vec1/2 come from offered free packs".

Recorded against 10 banks rather than 5, because the same source answers more
than the bank that prompted the question: org_jungle_breaks shares its CD,
h2ogmcp and h2ogmcy are the same Hydrogen GM kit as h2ogmhh, and vec1_acid and
vec1_snare are the same VEC pack as vec1_claps. Each carries the source in its
note, so the reasoning survives the session that produced it.

This is what ranking by leverage was for: five answers moved 60 banks from 19
clear to 29, and the four heaviest gates in the record (14, 9, 9 and 8 tracks)
are now open. 31 remain, and the next one down is `snare` at 4 tracks — likely
the same CC0 family as kick and risers, but that is a guess and a guess is
exactly what this ledger exists to not record.

PLN: "cant push the single tracks when samples hit, but full mix might well
pass!" — which matches the measurement (an isolated track flagged where the
87-minute mix passed). So the gate on a per-track release is per BANK, and this
tool answers "what is in here and where did it come from". The verdict stays
his, recorded once in rights_ledger.json so it is never re-litigated.

THE DISCRIMINATOR IS THE WHOLE COMMIT. "Lives in the Dirt-Samples folder" is not
"is a Dirt-Samples bank": 56 of OPAL-26's 60 banks resolve to that directory,
including the_revolution, like_sugar, desire, wap and crimewave — because local
banks were dropped in beside the quark's own. Classifying by location would have
returned a confident, comprehensively wrong LOW-RISK verdict on the most
obviously sampled material in the set. That is the same shape as reading a role
off a sample's name.

The quark is a git checkout, so `git ls-files` settles it exactly:
217 upstream banks, 509 added locally. Tracked = ships with the quark under its
license, auto-verdict `dirt_samples`. Untracked = provenance unknown to the
tool, so `unknown`, which blocks by design. A bank in the score but not on disk
reports UNRESOLVED rather than passing as safe.

RANKED BY LEVERAGE, not alphabetically. 41 open banks reads as 41 equal chores;
in fact five gate almost the whole record — jungle_breaks (14 tracks), h2ogmhh
(9), kick (9), risers (8), vec1_claps (6). Answering those five changes the
shape of the release; answering `take5` changes one track. Keystone first.

First run on OPAL-26: 60 distinct banks, 19 upstream and clear, 41 open, so all
15 tracks currently block. That is the honest starting position, not a failure —
and it is per-track only. The continuous mix remains the lower-risk artefact and
is a separate question.

PLN: "cant push the single tracks when samples hit, but full mix might well
pass!" — which matches the measurement (an isolated track was flagged where the
87-minute mix passed). So the continuous mix is not a by-product of the release,
it is the artefact most likely to survive, and --include-mix makes it a first-
class entry in the upload plan.

It is listed FIRST on purpose: if an upload run dies halfway, it dies having
landed the important thing.

The description carries the tracklist with timecodes, and those come from the
CUMULATIVE RENDERED durations rather than from segment arithmetic. The mix is
literally these files concatenated, so summing what came out is exact — and it
stays exact through effects that lengthen a track, which is not hypothetical
here: CRIME carries a 2s rest and REVOLUTION a 650ms reverb tail, so segment
maths would have every timecode after track 13 drifting.

Timecodes switch to h:mm:ss past the hour. The last four tracks of a 73-minute
set are all past 60 minutes, and "69:15" is a number nobody can place.

The mix title is composed from canonical FIELDS (title · venue · year), never
from a remembered string: "Sunset Forest — Opal Festival 2026 (full set)". The
format lives in the code, the facts stay in Web/www.

`sc album --plan` wants titles, files and tags as JSON. Typing that by hand is
exactly how a release ships with the wrong album name — split_bandcamp.py once
carried an ALBUM string that was simply wrong and nothing downstream could tell.

So build_release_plan.py generates it, and every field is copied from the one
place that owns it: gig metadata from Web/www content/lives/{year}/{slug}.md,
per-track section/style/sample-banks from that gig's tracks.json, release order
and durations from the rendered segments, approval from the ear file's
release_signoff. `_provenance` records each source, so a wrong string is traced
rather than argued about.

TWO REFUSALS, both because the failure they prevent is invisible after upload.

1. NO SIGNOFF, NO PLAN. The ear file's release_signoff is pinned to the segments
   PLN approved; if it is missing, or the rendered FLACs are NEWER than it, the
   record on disk is not the record he cleared. An upload is hard to take back,
   so the check belongs before it and not in a checklist. --force overrides and
   says so in the log.

2. NO ROW, NO PLAN. The first run joined the tracklist on the raw title and
   silently missed 4 of 14 — because the canonical names are written in PLN's
   blog voice ("There's **Something About Drums** <3", "Am i _Doing it Right_",
   "GHOSTS IN THE TOILETS") while the segments carry the plain form. The plan
   looked complete: 14 tracks, right durations, right files. Four of them just
   had empty genre, empty section and NO sample banks — and the sample-bank list
   is the input to the rights question. A parser miss must never become a quiet
   gap in the catalog, so an unmatched title now refuses the whole plan and
   prints both name lists side by side.

The fix for the join itself is match_key(): strip emphasis, hearts, case and
punctuation for MATCHING ONLY, while every value that ships still comes from the
canonical record verbatim. Which surfaced a real question rather than hiding it
— the two sources disagree about three names, so --titles chooses, defaulting to
canonical, and the diff is printed:

    "There's Something About Drums" -> "There's Something About Drums <3"
    'Perfect'                       -> 'Perfect <3'
    'Ghosts in the Toilets'         -> 'GHOSTS IN THE TOILETS'

Those decorations are his voice, not markup, and clean_title already knew to
keep them. Verified against the shipped audio: 14 tracks, durations matching the
rendered files including CRIME's 2s rest (271.1s) and REVOLUTION's reverb tail
(205.6s). Every track carries `_rights_checked: false` — the banks are listed,
nobody has cleared them.

PLN on the rebuilt seams: "listened to 13... perfect end for crime. revolution
starts good. listened to 99... all good perfect ending!"

That listen is the one that counted, and it is worth saying why: both clips were
audio BUILT FROM his approvals rather than audio he had approved. The 2s rest and
the MORE reverb tail existed only as instructions until this pass — a chain of
individually-approved edits can still add up to an ending nobody has heard.

Recorded in three places, each for a different reader:
  - `release_signoff` in the ear-boundary file — machine-checkable provenance,
    pinned to segments_v4 as rendered today. Any later re-render invalidates it;
    the note says so, so a future uploader can refuse rather than guess.
  - performance_notes.md — the ear-feedback corpus, per the archivist rule.
  - TASKS_DUMP.md — A1 closed, the last gate marked CLEARED.

Two taste calls banked for future sets:

SILENCE IS A MUSICAL ELEMENT, AND IT BELONGS TO THE OUTGOING TRACK. His fix for
the CRIME->REVOLUTION seam was not a longer fade or a different cut point — the
cut was already approved. It was "add after seam 2s silence in crime file". He
wanted the last official track to end on its OWN silence and the encore to start
clean. Future set-ending seams should offer a rest as a candidate, not only
fades.

HE REVISED THE REVERB AFTER LIVING WITH IT. Auditioned in isolation: "pick
subtle". Heard as the record's ending: "allez lets use the B version, the more
option" — roughly 2.7x the ring (650ms top tap vs 240ms). An effect judged on a
bare clip and the same effect judged as an ending are different judgements, so
render the A/B IN PLACE next time.

Both were a second listen changing the answer, which is the whole argument for
keeping the audition loop cheap: neither correction cost more than a re-render.

build_release_joins hardcoded its first closing clip as CLOSE · DRY, "what ships
today". That was true exactly once — before any reverb was chosen. The clip is
cut from the RENDERED last track, so the moment PLN picked a preset the file he
auditioned had the echo baked in and the label said it did not.

An audition UI that misdescribes what ships is the one bug this tool cannot
have: its entire job is to let the ear check the actual artefact, and a wrong
label turns a passed listen into a false clearance. Same family as the earlier
allow-list that silently dropped reverb_preset — the output looked clean and was
clean, of the wrong thing.

Now the first entry is CLOSE · SHIPPED and reads the preset out of the release
segments, so it renders as "SHIPPED · MORE tail baked in". Names the artefact
from the data that produced it rather than from an assumption frozen at the time
the code was written. Wrapped in try/except: a missing segments file drops the
suffix rather than blocking the audition.

The A/B variants are unchanged and still opt-in behind --close-ab.

Two ear calls on the OPAL-26 record, one of which needed a new concept.

PLN, having heard the CRIME->REVOLUTION seam: "approved #13 seam, but lets add
after seam 2s silence in crime file, then seam is start of [the] revolution."
And on the closing echo, after living with it: "allez lets use the B version,
the more option" — so the ship-preset moves subtle -> more.

The silence is the interesting half. The pipeline knew two kinds of answer:
`verified` boundaries (move one, both neighbours shift) and `edits` trims (audio
is DROPPED, a gap opens, the continuous mix skips it). A rest is neither — it
ADDS time. So `pad_end_s` is a third kind, and where it lives is the whole
decision: the 2s belongs to CRIME, so it ships inside track 13's file AND at the
same place in the continuous mix, and REVOLUTION still begins on its first
sample in both forms. Had it been modelled as a gap between tracks it would have
existed only in the mix and track 13 would have ended on the hard cut.

Implemented with `apad` — the same filter whose one-second-per-second literalism
was a BUG two commits ago, where it was misused as reverb headroom and shipped
~2.3s of trailing zeros. Here that literalism is exactly the feature: 2.0 in,
2.0000s out. Silence as an accident of a misunderstood filter is a defect;
silence a listener asked for is a rest. Same filter, opposite verdict, and the
comment now says so where the next reader will hit it.

Ordering matters and is documented: the pad runs LAST, after the fades and after
any reverb ring. Padding first would hand the fade silence to act on, and the
fade's own start is measured from the un-padded duration. In the reverb graph it
attaches after the dry/wet concat, not inside either branch.

`expected_dur` now predicts pad + aecho's longest tap, so `verify` still compares
against INTENT rather than against whatever came out — the property that caught
the apad bug in the first place. `stage_continuous` prints rests separately from
gaps, because lumping them together is the exact confusion this commit exists to
prevent.

Validated, all measured not assumed:
  - verify ALL OK, 14 tracks x 2 variants, 48000/24
  - #13 271.050s = 269.05 + 2.00; #14 205.550s = 204.90 + 0.65 (more's 650ms
    top tap — subtle's was 240ms, so the duration alone proves which shipped)
  - sample-exact: the last 2.0000s of CRIME are all zeros and the last non-zero
    sample sits precisely on the 2.000s mark
  - continuous 4361.35s both variants, OK against intent
  - the rebuilt seam-13 audition clip carries 2.0000s of silence ending exactly
    at the 20.00s seam marker: the rest is CRIME's, the marker is REVOLUTION's
    first sample

Kept deliberately: the 1s duck to 50% stays alongside the new rest. They answer
different complaints — the duck softens the cut, the rest separates the encore.

Written as documentary source material: three detectors' numbers, why the
best-looking one was the least trustworthy, and the reframing (onset vs
takeover) that a failed lens produced.

The reverb tail shipped with `apad=pad_dur=2.5` on the reasoning that ffmpeg
would otherwise chop the echo at the last sample. That reasoning was wrong, and
the verify stage is what exposed it: REVOLUTION came out 207.64s against a
predicted 207.40, and chasing the 0.24s led to the actual behaviour.

Measured, four ways:

    no apad   -> 5.240s wet, 0.000s trailing silence   (full ring, nothing cut)
    apad=0.05 -> 5.290s wet, 0.050s trailing silence
    apad=0.35 -> 5.590s wet, 0.350s trailing silence
    apad=2.5  -> 7.740s wet, 2.500s trailing silence

aecho extends its OWN output by its longest tap (240ms for subtle), so the ring
was never at risk. Every second of apad simply became trailing digital silence,
one for one. The rendered record therefore ended with ~2.3s of pure zeros —
which is precisely the defect PLN flagged at the other end of the record
("trim leading silence tho"), reintroduced by me at the close.

Two things worth keeping from how this surfaced. The 0.24s mismatch was real
information, and the tempting fix — `atrim` the output back to the predicted
length — would have clipped the end of the ring while making the check go green:
the prediction was wrong, not the audio. And the fix only became findable
because verify compares against a number derived from intent rather than from
whatever the renderer happened to produce.

expected_dur is now duration + aecho's longest tap, exactly. REVOLUTION: 205.14s.

PLN picked SUBTLE from the three-way close A/B. Promoting it exposed two bugs
that would each have shipped something he never heard.

1. The reverb existed TWICE and the copies disagreed. render_release had a
   single 833ms slap (aecho=0.8:0.5:833:0.35) applied to the WHOLE track;
   build_release_joins had a three-tap preset applied to the tail only. Setting
   `reverb_tail_s` would therefore have washed all of REVOLUTION with an echo
   nobody auditioned. The preset table now lives in render_release and the A/B
   builder imports it, so what ships is bit-for-bit the chain he compared.

2. apply_boundaries forwarded edit keys through an ALLOW-list, which silently
   dropped `reverb_preset`; the renderer then saw no preset and fell back to no
   reverb at all. A missing edit is invisible in the output — you get a clean
   render of the wrong thing — so it now deny-lists the keys it consumes and
   forwards everything else.

Caught by inspecting the built filter graph before rendering rather than after,
which is the only reason this is a commit message and not a re-render.

The tail reverb is a split graph, not `-af`: head dry, last 5s through apad then
aecho, concatenated. The apad matters — without it ffmpeg chops the ring at the
final sample, reintroducing the exact hard stop the reverb exists to soften.
Verify accounts for the 2.5s ring, so REVOLUTION is expected at 207.4s not
204.9s rather than being flagged as a mismatch.

Full pipeline run on the edited segments. All green:

  split      14 tracks x streaming + club
  verify     every duration exact, 48000/24
  continuous 14 segments, 72.6 min, 3 gaps -> 4358.70s both variants

The three gaps are the trims, and seeing them enumerated is the point:
  [ 530.35 ..  531.35]    1.00s   the silence PLN wanted cut to 1s
  [ 892.96 ..  893.00]    0.04s   WAP's truncation burst
  [4156.30 .. 4566.47]  410.17s   Desire, plus his CRIME/REVOLUTION trims

Verified the WAP fix by measurement rather than by assuming the trim landed:
peak in the track's last 100ms is now -55.0 dBFS, down from -15.1, and it decays
to -70 instead of being chopped mid-transient. What remains near the end is
ordinary music ringing out into the 30ms guard fade, which is the intended
result — the truncated sound is gone, not merely quieter.

Release-check set rebuilt: 17 clips (open + 13 seams + 3 closes). Smoke passes
against the production server.

PLN: 'maybe with reverb over last 5s so we hear it slightly echo as last sound'.
Rendered as an A/B rather than baked in — an echo on the final sound of a record
is a taste call, and 'maybe' is not a decision.

Two flavours (subtle / more) plus the dry render, so the comparison is three
clips in the same view. The wet part is the TAIL ONLY: a global reverb would
wash the whole ending, and everything before the last 5s stays identical to dry.
The tail gets apad before the echo so the ring has somewhere to go — without it
ffmpeg chops at the last sample and the 'echo as last sound' becomes another
hard cut, which is the thing being fixed.

The release check turned up four fixes and one boundary move. The pipeline could
express none of them, because it only knew about boundaries. It now separates
two things that look alike and are not:

  `verified`  a BOUNDARY: moving it shifts both neighbours (butt-joined set)
  `edits`     a per-track TRIM/FADE: the audio is DROPPED, a gap opens, and the
              continuous mix must skip it too

Confusing them silently hands a neighbour a second of someone else's silence —
which is the exact artefact these edits exist to remove.

Applied, all verified by ratio against the unfiltered master rather than by
reading back the command line:

  #1  Bombe      end -1.0s   PLN: "trim silence to 1s silence from 00:17".
                             Measured: audio ends 527.90, then 2.0s of -60..-100.
  #2  WAP        end -45ms   PLN heard "a sound just at seam ... is an error".
                 +30ms fade  The error was at WAP's END, not Drums' head: the
                             last 40ms jump -57 -> -15 dBFS, a sound truncated
                             mid-decay. An 80ms fade only reached -26.8 dB —
                             hidden, not gone — so the burst is now dropped
                             outright and the fade only guards the new edge.
  #12 Mafia      +1.66s      boundary MOVE: heard as a seam, it wants more Ghosts
  #13 CRIME      end -10.0s  PLN: "cut at 0:10 its better. have fade from 0:09 to
                 duck to 50% 0:10 from 100 to 50% to lower the sudden cut"
  #15 REVOLUTION start +18.9s PLN: "start revolution at 0:38:9 on a fade of the
                 2s fade-in   drums to not be so sudden"
                 end -15.0s   PLN: "end at 0:15"

Measured gain curves confirm each: CRIME flat 1.0 then ramping to 0.546 over the
last second; REVOLUTION 0.022 -> 1.0 across 2s; WAP 1.0 until the fade. Every
duration exact.

`continuous` was rewritten as a consequence. It used to cut merged "kept spans"
from the master, which was right for boundaries and would have been silently
WRONG here: the mix would have played un-faded audio while the tracks were
faded, with nothing to flag it. It now cuts the same segments through the same
filter chain and concatenates them, so the mix is literally the tracklist and
the two cannot drift. Gaps fall out for free.

PLN's raw release-check export is committed as provenance. Still open: his
"maybe with reverb over last 5s so we hear it slightly echo as last sound" —
supported as `reverb_tail_s`, deliberately left off pending an A/B.

PLN: "this becomes our tooling, often a set will be postprocessed as we did —
reusable scripts and views plz". So the per-gig finish.sh is replaced by
spec-driven tools: a new gig is now a copy of judge_specs/<gig>.json, never a
copy of a script. POSTPROD.md documents the whole flow and the trap each stage
exists to avoid.

render_release.py — split every variant, verify durations and format, and
re-render the continuous mixes. Ran clean: 14 tracks x streaming+club, all
durations within tolerance, 48000/24.

Its `continuous` stage answers PLN's other catch: "imo the master club rec will
also have desire removed". A set is released TWICE — as tracks, and as the
unbroken mix — and cutting a track had only fixed the first; both continuous
masters still played Desire in full. This matters past tidiness: the continuous
upload is the lower-risk rights path (an isolated track was flagged on
SoundCloud where the 87-minute mix passed), so the mix is the artefact most
likely to ship and it has to match the tracklist. The excision derives its kept
spans from the same segments the tracks came from, so mix and tracklist cannot
disagree. Both variants now render to 4403.65s = 73.4 min, matching the sum of
the 14 tracks exactly:
    [1.45 .. 4166.30] 69.4 min  +  [4547.57 .. 4786.37] 4.0 min

build_release_joins.py — the confirmation pass PLN asked for ("i wanna confirm
all tracks start/ends/transitions"). It deliberately does NOT use the master:
once Desire is dropped, the seam a listener hears (CRIME straight into
REVOLUTION) exists only in the rendered output, and a master-based window there
would play six minutes of a track that does not ship. Building from the split
FLACs also audits the files that actually ship, so a split error surfaces before
upload rather than after. 15 clips: the record's opening, 13 seams, and its
closing.

apply_boundaries now emits the splitter's native shape — `track` is RELEASE
position because tidal_ears.master split uses it for both filename and the
`track=N/total` tag; performance order stays as `perf_track`. Emitting
performance order would have named the last file "15 - REVOLUTION" in a
14-track album and tagged it 15/14, which stores reject.

Both UI sets pass bounds-smoke (11 assertions each). The test now derives its
data file from the page's own ?set= — hardcoding it meant it could assert
against a different set than the browser had loaded, passing or failing for
reasons unrelated to the code.

PLN's last call: "00:31:3 is a decent end of crimewave to cut early on end of
the crime sound". Read off the transport, which shows CLIP time, and #14's clip
starts at 4135.0 — so master 4166.3. The audio agrees rather than merely
permitting it: the crime sound gaps to -71 dB at 4164.5 and 4166.3 sits just
past that on its decay, 13.7 s before the nominal 4180.0. Recorded with that
mapping written out, because clip-vs-master is the one confusion that would
shift a cut by 45 s and look plausible.

apply_boundaries.py turns the ear file into segments_v4.json. Made a tool rather
than a hand edit because this is the step that shipped a wrong album once, and
its three rules are each silently destructive to get wrong:

  - starts come from the ear, ends from the neighbour (butt-joined), so editing
    one start moves two tracks;
  - a track CUT from the release still owns its boundary — Desire is dropped but
    the edge into Desire is where Vague de CRIME ends, and ignoring it would run
    the last official track into Desire's intro;
  - release position is not track number: dropping a track renumbers the album
    but must not renumber the provenance, so both `n` and `track` are emitted.

It refuses to write on overlap, non-positive duration, out-of-master range, or
an ear-verified start that failed to reach the output. All green:
14 tracks, 73.4 min kept of a 79.8 min master, 6.4 min dropped (Desire).

Remaining unverified edge, for the record: #2's start (531.35) is still the
nominal, so #1's end rides on it. It was never flagged in the judge pass.

Ear feedback archived in performance_notes.md, including the finding that #11
and #12 disagree about which fraction is right — takeover on one, mid on the
other, 8 s apart. Two adjacent cuts, opposite answers: where a cut belongs is a
musical judgement about that handover, not a parameter to fit.

PLN made the four calls in the boundary lab. Merged into `verified`, so the
ear-boundary file now covers #1 and #3-#13 and #15; `unjudged` is empty. The raw
export is committed next to it as provenance rather than being consumed and
thrown away.

  #11  3557.33   takeover was +0.13s  -> the machine had it
  #12  3680.10   takeover was -8.00s  -> "here the right cut is mid :)"
  #13  3887.25   ear-only, no candidate could exist
  #15  4547.57   ear-only, no candidate could exist

Worth recording that #11 and #12 disagree about WHICH fraction is right: on one
the takeover was the cut, on the other the midpoint was, 8 s earlier. That kills
any remaining hope of a single universal fraction and confirms the tool's shape
was the right call — offer the candidates, let the ear pick, do not average.

The unnoticed gap: #13's END. The set is butt-joined, so that edge is the
boundary INTO Desire (nominal 4180.0), which was never verified because Desire
itself is cut from the release — it looked like work that no longer mattered.
It is the opposite: with Desire dropped, that edge is where the last official
track ends, and if it is late then Desire's intro bleeds into the end of the
record. Rendered it as a fifth boundary; the builder now reads
`cut_from_release` and labels such an edge "END of #13 Vague de CRIME" with an
on-screen explanation, so the next gig cannot lose the same edge the same way.

Also made bounds-smoke pick its subject by content instead of position: it broke
the moment #11 became settled and lost its candidate buttons, which is a data
change, not a regression. It now prefers a boundary that still has a machine
candidate and falls back to the nominal marker every boundary carries. 11/11
against the production server.

The set-judge answers "is this track a keeper". This answers the question that
actually blocked the release: where exactly does one track become the next.
After three failed detectors (cut_lens3 declared a dead end in 5f7db02a), #13 and
#15 are ear-only by nature — the two tracks share their sounds across the switch,
so no timbral lens can see the handover. The tool's job is therefore to make one
ear call cheap, not to avoid asking.

build_bounds_set.py renders a ±45 s FLAC clip per boundary instead of seeking the
817 MB master. A boundary audition is a scrub — dozens of small seeks around one
point — and seeking a long FLAC depends on a seektable the browser may not use
well; local clips make every seek instant for a few MB total. Clips are
re-encoded, never `-c copy`, because FLAC stream-copy snaps to frame boundaries
and every marker inside the clip would inherit that offset. Clip time and master
time are kept explicitly apart (`clipStart`), converted in exactly two functions.

The UI shows each cut's candidates as labelled markers on the waveform, drawn as
regions rather than positioned divs so they stay glued to the audio through zoom
and scroll. `takeover` leads the list because it landed within 0.7 s on both
boundaries that also had ear answers — with the caveat printed on screen, since
that is n=2 on the cases that were already easy. Boundaries with NO candidate are
shown with an explicit notice rather than omitted: those are precisely the ones
needing a human, and hiding them would hide the work.

Fixes a real bug in the SHARED player while here: `ws.zoom()` needs a decoded
buffer, which the peaks path never has, so it threw "No audio loaded" from an
effect and blanked the entire page. Same message as the peaks+url trap, entirely
different cause. Now guarded and failed-soft — zoom is a convenience and must
never take the tool down. The judge had this latent too.

bounds-smoke.mjs, 11 assertions, all passing. Two of them exist because the first
version of this test passed while proving nothing: querySelector('audio') is null
by construction (wavesurfer owns the element and never puts it in the DOM), so
the playback probe would have "passed" forever on a dead transport. It now reads
the transport clock and the Pause button — what a human sees. A positional
selector also silently picked the header's counter instead of the clock, hence
the explicit data-testid.

Two changes to the ear-boundary ground truth, kept deliberately distinct.

#1 was the last GO with an unfinished instruction — PLN said "trim leading
silence tho" without an amount. The amount is now measured rather than
estimated: every sample is EXACTLY zero up to sample 64038 (1.452109 s @
44.1 kHz), and the first audible frame peaks at -28 dBFS. That is a sample-exact
scan, not a threshold and not a detector, which is why it is allowed into a file
whose header forbids detector output. Recorded as start=1.45, keeping a ~2 ms
guard so the first transient cannot be clipped, with the full measurement and
method stored alongside it for audit.

#11 and #12 gain machine PROPOSALS in a new `candidates` block, structurally
separate from `verified` so nothing can be mistaken for a confirmed boundary.
On the two boundaries that also have ear answers, the `takeover` estimate landed
within 0.7 s (#8 2726.25 vs 2726.4, #10 3268.3 vs 3269.0) — which is a reason to
audition takeover first, not a reason to trust it: n=2, on the cases that were
already easy.

#13 and #15 are listed with an explicit NO CANDIDATE and the reason, so a future
reader does not go looking for numbers that cannot exist: zero voting orbits
across three gates and two estimators, because those transitions share their
sounds and a timbral lens is blind to them by construction.

The Claude-Code Task API is not reachable from this session (TaskList/TaskCreate/
TaskUpdate/TaskGet all absent), so the live board — last seen at 112 tasks —
could not be read or rewritten. Rebuilt the tree from durable sources instead:
board-archive.md (ids exact, completed through 2026-07-29), the numbered
achievement logs, the memory store, and git.

Structured as six epics with the work nested underneath: OPAL-26 release (the
only one blocking a shipment), cut/boundary detection, the floor problem, rig &
hardware, open taste calls, completed. Each item carries the measurement or the
quote that justifies it rather than a bare title, so it survives a cold read.

Honest about provenance: ids in the #150+ range come from the lost board via
session context and cannot be re-verified, so the file says to treat a #17x
number as a name, not a key.

This session's outcomes are slotted in place: #1's leading silence measured
(1.452s), the timbral cut lens declared a dead end with its three-attempt table,
and #13/#15 escalated to ear-only calls.

The medoid + effect-size gate was meant to buy coverage after run 1 returned
"no separating orbit" for six of fourteen boundaries. It did the opposite:
boundaries with any voting orbit went 8/14 -> 4/14. Requiring cross-side
distance to beat within-side spread is a stricter test, not a better-aimed one.

The error table is seductive and is not evidence: u=0.85 scores median 0.4s,
worst 0.7s — but n=2, and those two boundaries (#8, #10) already had ear
answers. Four survivors cannot validate five candidate fractions, and a metric
computed on the cases that were already easy measures nothing.

The durable finding is the pattern across all three attempts: #13 Vague de
CRIME and #15 REVOLUTION have produced ZERO voting orbits in v2, v3 run 1 and
v3 run 2 — three gates, two estimators. That is not a tuning failure. Those
transitions have no orbit whose timbre differs materially across the switch;
the outgoing and incoming tracks share their sounds, so a timbral lens is
structurally blind there just as an activity lens is blind to a crossfade. A
fourth loosening can only admit noise, because there is no signal in this
feature space.

Declared a dead end in the docstring rather than tuned again. Two ways out are
recorded: change the feature (harmonic/key change, or sample-bank identity from
the score, which differs even when the spectrum does not), or accept #13/#15 as
ear-only calls — two timestamps, seconds of listening each.

Candidates that DID survive are kept in cut_candidates_v3run2.json for #8, #10,
#11, #12 as ear-confirmation inputs, not as boundaries.

v3 run 1 returned "no separating orbit" for six of fourteen boundaries,
including #13 and #15, the two the run existed to answer. Diagnosis was that
the gate compared ONE profile averaged over 40 s per side: a mean of band
percentages is a sound that never occurred, and 40 s of a livecoded track
averages toward the same grey for every orbit, so the orbits that actually
change look uninformative.

This replaces that with a distribution test:
  - reference windows are framed (3 s / 1.5 s hop) instead of averaged
  - each side is summarised by its MEDOID — an actual moment of the track —
    plus the median within-side distance, i.e. how varied that side is
  - an orbit votes only if it differs MORE across the switch than within
    either side (effect = sep - mean spread), not merely by a fixed distance
  - REF_MAX 40s -> 24s, so a reference stays one sound

NOT YET VALIDATED. Syntax-checked and smoke-run on boundary #11 only, which
still draws 3 voters and moves only its u0.15 estimate (3553.7 -> 3515.7);
whether #13/#15 recover needs the full 14-boundary run (~10 min) that has not
been done. Committed rather than parked so the reasoning is not lost — the
docstring's RESULT block still describes run 1 and must be rewritten with run
2's numbers before any boundary is taken from this.