feat: Shift+J/K/U/I jump to first/last/loudest/quietest section

Holding Shift with the section-navigation keys jumps straight to the
extreme in that direction instead of stepping one at a time:
- Shift+J / Shift+K -> first / last section in time order
- Shift+U / Shift+I -> loudest / quietest section

Works in both clip-queue navigation (stepClip gains a jump flag) and
in-player full-file navigation. Visible key-hint note and README updated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -154,12 +154,12 @@ The browser UI (HTML/CSS/JS) lives in `webui.html`, which `web.py` loads at star
 Shows recordings grouped by day with collapsible sections. Features:
 
 - **Day groups** — recordings are grouped under a collapsible day heading showing date, file count, total duration, and total size. The most recent day is expanded by default; older days start collapsed. Expanded state is preserved across filter changes.
-- **Day highlights** — click **Highlights** on any day heading to run loudness analysis across all WAV/FLAC files in that day. The button is a toggle: clicking again collapses the panel, and re-expanding it reuses the already-computed results (they are only recomputed when the analysis parameters change). A **· analysed** suffix on the button marks days where every file already has a cached analysis for the current parameters, i.e. highlights open instantly. The panel is plain text and buttons in linear reading order (screen-reader friendly): files-analysed/section totals, a key hint, then the section chips. When a day has more sections than fit as chips, the chips are the top 50 by score (loudest-above-background first) so the most promising events are reviewed first; long chip lists are collapsed behind a toggle button so the panel stays compact. J/K still steps through all sections in time order, and U/I steps through them by loudness.
+- **Day highlights** — click **Highlights** on any day heading to run loudness analysis across all WAV/FLAC files in that day. The button is a toggle: clicking again collapses the panel, and re-expanding it reuses the already-computed results (they are only recomputed when the analysis parameters change). A **· analysed** suffix on the button marks days where every file already has a cached analysis for the current parameters, i.e. highlights open instantly. The panel is plain text and buttons in linear reading order (screen-reader friendly): files-analysed/section totals, a key hint, then the section chips. When a day has more sections than fit as chips, the chips are the top 50 by score (loudest-above-background first) so the most promising events are reviewed first; long chip lists are collapsed behind a toggle button so the panel stays compact. J/K still steps through all sections in time order, and U/I steps through them by loudness. Holding **Shift** jumps straight to an extreme: **Shift+J**/**Shift+K** to the first/last section in time, **Shift+U**/**Shift+I** to the loudest/quietest.
 - **Inline playback** — collapsible `Play` button per row; audio loads lazily via a seekable `/stream/` endpoint with HTTP Range support. Metadata is fetched immediately so the duration is visible without pressing play.
 - **Loudness analysis** — on demand per file; computes RMS per 100 ms window and lists sections that stand out above the background as clickable chips (no visual waveform — the UI is built for screen-reader use). Detection is **adaptive**: a rolling noise floor (20th percentile per 30 s block) is estimated across the file, and a section is flagged when the level rises at least *margin* dB (default 12) above that floor. Slow ambience changes — rain setting in, day/night traffic hum — move the floor instead of producing false positives. Each section gets a **score** used to rank it: its peak dB above the floor, capped by the sharpest rise within 0.5 s. Abrupt events — voices, impacts, barks — rise fast, so their score is their full prominence; a gradual swell (a gust, a distant approaching car) that drifts up faster than the floor can track still gets flagged, but scores near zero and sinks to the bottom of the highlight ranking. Supported for WAV and FLAC (FLAC requires `numpy` + `soundfile`). Pure-Python fallback for WAV when numpy is absent. Results are cached in `recordings/analyses/<filename>.analysis.json`; subsequent requests at the same margin, min-gap, and min-duration settings return instantly without re-reading the audio. The cache file is deleted automatically when the audio file is deleted. Orphaned cache files (audio deleted outside the UI) are pruned on startup.
 - **Grace period** — configurable in the controls bar (default 2 s). Loud sections separated by less than this gap are merged into one. Raise this (e.g. to 15–30 s) when a single event generates many timestamps due to brief quiet gaps within it.
 - **Min duration** — configurable in the controls bar (default 0.5 s). Loud sections shorter than this (after grace-period merging) are discarded, so isolated sub-second pops — a click, a single raindrop — don't flood a day with thousands of near-zero-length sections. Set to 0 to disable.
-- **Clip playback** — clicking a loud-section chip plays a short server-rendered WAV clip (`/api/clip`, pre-roll included) in a player bar at the bottom of the page. Playback starts instantly even for sections deep inside multi-hundred-MB FLACs, because the browser never has to seek the full file. The player bar labels each clip with the wall-clock time it occurred (derived from the recording's filename) and its position in the queue, e.g. `03:46:20 to 03:46:22 (73 / 187)`; the filename and score are in the label's hover tooltip. **J** / **K** (or the **Prev** / **Next** buttons) always step through the queued sections in time order — one file's, or a whole day's after **Highlights**. **U** / **I** step through the same queue by loudness instead: **I** plays the next-loudest section, **U** goes back up the ranking, so a day with thousands of detections is reviewed loudest-first for as long as it stays interesting — there is no top-N cutoff, just stop when it gets boring. The auto-advance radio in the player bar picks what happens when a clip ends: **Don't auto-advance**, **Auto-advance** (next section in time), or **Auto-advance highlights only** (next section by loudness) — it never changes what J/K do. The same keys work during full-file playback, seeking the open recording to the next section in time (J/K) or by loudness (U/I). **Open in file** (or the **O** key) switches to the full recording at the same position for context; each chip click also pre-fills the cut panel.
+- **Clip playback** — clicking a loud-section chip plays a short server-rendered WAV clip (`/api/clip`, pre-roll included) in a player bar at the bottom of the page. Playback starts instantly even for sections deep inside multi-hundred-MB FLACs, because the browser never has to seek the full file. The player bar labels each clip with the wall-clock time it occurred (derived from the recording's filename) and its position in the queue, e.g. `03:46:20 to 03:46:22 (73 / 187)`; the filename and score are in the label's hover tooltip. **J** / **K** (or the **Prev** / **Next** buttons) always step through the queued sections in time order — one file's, or a whole day's after **Highlights**. **U** / **I** step through the same queue by loudness instead: **I** plays the next-loudest section, **U** goes back up the ranking, so a day with thousands of detections is reviewed loudest-first for as long as it stays interesting — there is no top-N cutoff, just stop when it gets boring. The auto-advance radio in the player bar picks what happens when a clip ends: **Don't auto-advance**, **Auto-advance** (next section in time), or **Auto-advance highlights only** (next section by loudness) — it never changes what J/K do. Holding **Shift** with any of these jumps to the extreme in that direction — **Shift+J**/**Shift+K** to the first/last section in time, **Shift+U**/**Shift+I** to the loudest/quietest. The same keys work during full-file playback, seeking the open recording to the next section in time (J/K) or by loudness (U/I). **Open in file** (or the **O** key) switches to the full recording at the same position for context; each chip click also pre-fills the cut panel.
 - **Cut & download** — `Cut` button opens the player row and reveals a cut panel. Enter start and end times in `m:ss` or `h:mm:ss` format and click **Download cut** to receive an ffmpeg-trimmed copy without re-encoding. Requires ffmpeg (included in the Docker image). The cut is named with the real wall-clock span it covers — `<YYYYMMDD>_<HH-MM-SS>_<HH-MM-SS>.<ext>`, e.g. a 22:31:30→22:32:30 slice of a recording started at 22:00:00 becomes `20260523_22-31-30_22-32-30.flac`.
 - **Filters** — live filename search and from/to date pickers above the table; applied client-side with no additional requests. Shows `N of M shown` when a filter is active.
 - **Delete** — `Delete` button per row with confirmation prompt; disabled for files currently being recorded; sends `DELETE /api/files/<name>` and re-renders the table.

webui.html

@@ -410,18 +410,20 @@ const advanceMode = () =>
   document.querySelector('input[name="clip-adv"]:checked')?.value || 'off';
 
 // Step the clip queue by dir (±1): in time order, or with byScore down/up
-// the loudest-first ranking (next = next quieter).
+// the loudest-first ranking (next = next quieter). With jump=true, go straight
-function stepClip(dir, byScore) {
+// to the extreme in that direction (first/last section, or loudest/quietest).
+function stepClip(dir, byScore, jump) {
   if (!clipQueue.length) return;
   if (byScore) {
     const order = scoreOrder(clipQueue);
     const pos   = order.indexOf(clipCursor);        // -1: nothing played yet
-    const next  = pos === -1 ? (dir > 0 ? 0 : -1) : pos + dir;
+    const next  = jump ? (dir > 0 ? order.length - 1 : 0)
+                       : pos === -1 ? (dir > 0 ? 0 : -1) : pos + dir;
     if (next >= 0 && next < order.length) playClip(order[next]);
     else announce(dir < 0 ? 'Loudest highlight reached' : 'End of highlights');
     return;
   }
-  const i = clipCursor + dir;
+  const i = jump ? (dir > 0 ? clipQueue.length - 1 : 0) : clipCursor + dir;
   if (i >= 0 && i < clipQueue.length) playClip(i);
   else announce(dir < 0 ? 'Beginning of sections' : 'End of sections');
 }
@@ -534,8 +536,9 @@ async function analyse(idx, filename, cell, btn, force = false) {
 }
 
 // J/K = previous/next section in time order, U/I = up/down the loudest-first
-// ranking, O = open the current clip in the full file.
+// ranking, O = open the current clip in the full file. Holding Shift jumps to
-// Only when focus is not in an input.
+// the extreme in that direction: Shift+J/K = first/last section in time,
+// Shift+U/I = loudest/quietest. Only when focus is not in an input.
 document.addEventListener('keydown', e => {
   if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return;
   if (e.ctrlKey || e.metaKey || e.altKey) return;
@@ -545,10 +548,11 @@ document.addEventListener('keydown', e => {
   if (key === 'o') { openClipInFile(); return; }
   const dir     = (key === 'j' || key === 'u') ? -1 : 1;
   const byScore = key === 'u' || key === 'i';
+  const jump    = e.shiftKey;
 
   // Clip queue navigation (a chip was clicked or day highlights are loaded)
   if (clipQueue.length) {
-    stepClip(dir, byScore);
+    stepClip(dir, byScore, jump);
     return;
   }
 
@@ -570,10 +574,12 @@ document.addEventListener('keydown', e => {
   if (byScore) {
     // U/I walk the ranking; the anchor is the section the playhead sits in
     // (incl. its preroll lead-in). Anywhere else, I starts at the loudest.
+    // Shift jumps straight to the loudest (Shift+U) or quietest (Shift+I).
     const order  = scoreOrder(all);
     const curIdx = all.findIndex(s => cur >= s.start - preroll - 0.5 && cur <= s.end + 0.5);
     const pos    = curIdx === -1 ? -1 : order.indexOf(curIdx);
-    const next   = pos === -1 ? (dir > 0 ? 0 : -1) : pos + dir;
+    const next   = jump ? (dir > 0 ? order.length - 1 : 0)
+                        : pos === -1 ? (dir > 0 ? 0 : -1) : pos + dir;
     if (next >= 0 && next < order.length)
       jumpTo(all[order[next]], next, order.length, 'Highlight');
     else
@@ -581,6 +587,13 @@ document.addEventListener('keydown', e => {
     return;
   }
 
+  // Shift+J/K jump to the first/last section regardless of the playhead.
+  if (jump) {
+    const i = dir < 0 ? 0 : all.length - 1;
+    jumpTo(all[i], i, all.length, 'Section');
+    return;
+  }
+
   if (dir < 0) {
     for (let i = all.length - 1; i >= 0; i--) {
       if (all[i].start < cur - 1) { jumpTo(all[i], i, all.length, 'Section'); return; }
@@ -1012,7 +1025,7 @@ async function dayHighlights(dayId, analyzableFiles) {
     const note = document.createElement('p');
     note.className = 'quiet';
     note.style.marginTop = '6px';
-    note.textContent = 'J / K plays through all sections in time order, U / I by loudness (loudest first)';
+    note.textContent = 'J / K plays through all sections in time order, U / I by loudness (loudest first). Hold Shift to jump to the first / last section (Shift + J / K) or the loudest / quietest (Shift + U / I)';
     box.appendChild(note);
 
     const MAX_DAY_CHIPS = 50;