atris 3.61.0 → 3.63.0

package/scripts/det/ytnotes

@@ -1,11 +1,16 @@
 #!/bin/bash
 # ytnotes <youtube-url> [engine]: local YouTube notes, tweet-feed one-screen.
 # Zero Atris credits. yt-dlp pulls captions, a fast engine writes the notes.
-# Engines: haiku (default), atris-fast, gemini, grok, codex, cursor.
+# No captions: if mlx_whisper is installed (uv tool install mlx-whisper, Apple
+# silicon), the audio is transcribed on this machine instead. Otherwise the
+# script prints the paid command. ATRIS_YTNOTES_LOCAL_TRANSCRIBE=0 turns it off.
+# Engines: auto (default: fastest installed writer that answers: Gemini
+# Flash through agy, then Haiku, Codex, Cursor),
+# gemini, haiku, atris-fast, grok, codex, cursor. ATRIS_YTNOTES_ENGINE sets the default.
 # Outputs: $WORK/yt_${ID}.clean.txt (transcript), $WORK/yt_${ID}.md (notes).
 set -euo pipefail
 
-USAGE="usage: ytnotes <youtube-url> [haiku|atris-fast|gemini|grok|codex|cursor]"
+USAGE="usage: ytnotes <youtube-url> [auto|gemini|haiku|atris-fast|grok|codex|cursor]"
 
 case "${1:-}" in
   *youtube.com*|*youtu.be*|*youtube-nocookie.com*) ;;
@@ -13,30 +18,60 @@ case "${1:-}" in
 esac
 
 URL="$1"
-ENGINE="${2:-haiku}"
+ENGINE="${2:-${ATRIS_YTNOTES_ENGINE:-auto}}"
 CALLER_CWD="$PWD"
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 WORK="${TMPDIR:-/tmp}/ytnotes"
+# uv tool installs (yt-dlp, mlx_whisper) live here; appended so it never
+# shadows anything already on PATH.
+PATH="$PATH:$HOME/.local/bin"
+WHISPER_MODEL="${ATRIS_YTNOTES_WHISPER_MODEL:-mlx-community/whisper-large-v3-turbo}"
 mkdir -p "$WORK"
 cd "$WORK"
 
 # Printed metadata and a written English VTT are a hit even when yt-dlp exits 429.
 # A leaked WARNING|ERROR print line is not the video id.
 # Manual English is --write-subs. Auto English is often en-orig / en-US / en-GB.
+# Plain auto "en" is YouTube's machine translation and returns HTTP 429, which
+# made yt-dlp quit before writing en-orig. Ask for en-orig first, keep going.
 # Teach parses leftover yt_<id>.clean.txt stamps as cues.
 # Empty --print still keeps a VTT written in this run (id from the watch /
 # shorts / embed / live / e / nocookie embed URL or the new filename). A copied
 # #t= timestamp is stripped so leftover yt_<id> files still match. When VTT is
 # gone, leftover yt_<id>.clean.txt from a prior notes run is still a keep.
 # Another video's leftover clean.txt is not invent-keep.
+if ! command -v yt-dlp >/dev/null 2>&1; then
+  echo "This computer is missing yt-dlp, the free tool that reads YouTube captions." >&2
+  echo "Install it, then run the same command again:" >&2
+  echo "  Mac: brew install yt-dlp    Any computer: pipx install yt-dlp" >&2
+  exit 2
+fi
+
+# YouTube blocks old yt-dlp copies, and the failure looks like "no captions".
+# Warn when the version date (YYYY.MM.DD, maybe .N) is too old; keep going.
+# A version that does not parse stays silent.
+YTDLP_VERSION=$(yt-dlp --version 2>/dev/null) || true
+YTDLP_AGE=$(perl -MTime::Local -e '
+  my ($v, $max) = @ARGV;
+  exit 0 unless $max =~ /\A\d+\z/;
+  my ($y, $m, $d) = $v =~ /\A\s*(\d{4})\.(\d{1,2})\.(\d{1,2})(?:\.\d+)?\s*\z/ or exit 0;
+  my $t = eval { timelocal(0, 0, 12, $d, $m - 1, $y) };
+  exit 0 unless defined $t;
+  my $age = int((time - $t) / 86400);
+  print $age if $age > $max;
+' "$YTDLP_VERSION" "${ATRIS_YTNOTES_YTDLP_MAX_AGE_DAYS:-60}" 2>/dev/null) || true
+if [ -n "$YTDLP_AGE" ]; then
+  echo "Your yt-dlp is $YTDLP_AGE days old, and YouTube often blocks old copies. Update it: brew upgrade yt-dlp (Mac) or pipx upgrade yt-dlp" >&2
+fi
+
 existing=""
-for name in yt_*.en.vtt yt_*.en-orig.vtt yt_*.en-US.vtt yt_*.en-GB.vtt; do
+for name in yt_*.en-orig.vtt yt_*.en.vtt yt_*.en-US.vtt yt_*.en-GB.vtt; do
   [ -e "$name" ] || continue
   existing="$existing $name"
 done
 
 META=$(yt-dlp --no-update --quiet --no-warnings --skip-download \
-  --write-subs --write-auto-subs --sub-format vtt --sub-langs "en,en-orig,en-US,en-GB" \
+  --write-subs --write-auto-subs --sub-format vtt --sub-langs "en-orig,en,en-US,en-GB" --ignore-errors \
   --no-simulate \
   -o "yt_%(id)s" \
   --print "%(id)s|%(title)s|%(channel)s|%(duration_string)s" \
@@ -114,7 +149,7 @@ fi
 
 VTT=""
 if [ -n "$ID" ]; then
-  for name in "yt_${ID}.en.vtt" "yt_${ID}.en-orig.vtt" "yt_${ID}.en-US.vtt" "yt_${ID}.en-GB.vtt"; do
+  for name in "yt_${ID}.en-orig.vtt" "yt_${ID}.en.vtt" "yt_${ID}.en-US.vtt" "yt_${ID}.en-GB.vtt" "yt_${ID}.local.vtt"; do
     if [ -s "$name" ]; then
       VTT="$name"
       break
@@ -122,7 +157,7 @@ if [ -n "$ID" ]; then
   done
 fi
 if [ -z "$VTT" ]; then
-  for name in yt_*.en.vtt yt_*.en-orig.vtt yt_*.en-US.vtt yt_*.en-GB.vtt; do
+  for name in yt_*.en-orig.vtt yt_*.en.vtt yt_*.en-US.vtt yt_*.en-GB.vtt; do
     [ -s "$name" ] || continue
     case " $existing " in
       *" $name "*) continue ;;
@@ -135,11 +170,67 @@ if [ -z "$VTT" ]; then
     break
   done
 fi
+# No captions: transcribe the audio on this machine. Writes yt_<id>.local.vtt
+# and deletes the audio. Returns non-zero, with the reason in LOCAL_FAIL, when
+# the model is missing or a step fails.
+LOCAL_FAIL=""
+transcribe_locally() {
+  if [ "${ATRIS_YTNOTES_LOCAL_TRANSCRIBE:-1}" = "0" ]; then
+    LOCAL_FAIL="off"; return 1
+  fi
+  if ! command -v mlx_whisper >/dev/null 2>&1; then
+    LOCAL_FAIL="no-model"; return 1
+  fi
+  echo "No captions on this video. Transcribing the audio on this computer (free, about 1 minute per 15 minutes of video)." >&2
+  rm -f "yt_${ID}".audio.*
+  # YouTube refuses some media requests at random (HTTP 403) and allows the
+  # next one, so try the download three times before giving up.
+  local attempt downloaded=0
+  for attempt in 1 2 3; do
+    if yt-dlp --no-update --quiet --no-warnings --no-playlist \
+        -f "bestaudio[ext=m4a]/bestaudio/best" -o "yt_${ID}.audio.%(ext)s" "$URL" 2>"yt_${ID}.audio.err"; then
+      downloaded=1; break
+    fi
+    [ "$attempt" = 3 ] || sleep "$((attempt * ${ATRIS_YTNOTES_RETRY_SECONDS:-3}))"
+  done
+  if [ "$downloaded" != 1 ]; then
+    LOCAL_FAIL="download: $(grep -m1 ERROR "yt_${ID}.audio.err" 2>/dev/null || echo "yt-dlp failed")"
+    rm -f "yt_${ID}".audio.*
+    return 1
+  fi
+  local audio=""
+  for f in "yt_${ID}".audio.*; do
+    case "$f" in *.err|*.part) continue ;; esac
+    [ -s "$f" ] && audio="$f" && break
+  done
+  if [ -z "$audio" ]; then
+    LOCAL_FAIL="download: no audio file"; rm -f "yt_${ID}".audio.*; return 1
+  fi
+  if ! mlx_whisper "$audio" --model "$WHISPER_MODEL" --output-format vtt \
+      --output-dir "$WORK" --output-name "whisper_${ID}" --verbose False >"yt_${ID}.whisper.log" 2>&1; then
+    LOCAL_FAIL="transcribe: $(tail -n 1 "yt_${ID}.whisper.log")"
+    rm -f "yt_${ID}".audio.* "whisper_${ID}.vtt"
+    return 1
+  fi
+  # mlx_whisper drops anything after a dot in --output-name, so write a
+  # dot-free name and rename it.
+  mv -f "whisper_${ID}.vtt" "yt_${ID}.local.vtt" 2>/dev/null || true
+  rm -f "yt_${ID}".audio.* "yt_${ID}.whisper.log"
+  [ -s "yt_${ID}.local.vtt" ] || { LOCAL_FAIL="transcribe: empty transcript"; return 1; }
+}
+
 if [ -z "$VTT" ]; then
   if [ -n "$ID" ] && [ -s "yt_${ID}.clean.txt" ]; then
     : # leftover cleaned transcript from a prior notes run
+  elif [ -n "$ID" ] && transcribe_locally; then
+    VTT="yt_${ID}.local.vtt"
   else
-    echo "No English captions found for $URL. Falling back is manual (atris youtube process, 5 credits)." >&2
+    echo "No English captions found for $URL." >&2
+    case "$LOCAL_FAIL" in
+      no-model) echo "This computer has no local speech model to transcribe it." >&2 ;;
+      download:*|transcribe:*) echo "Local transcription failed (${LOCAL_FAIL})." >&2 ;;
+    esac
+    echo "Paid notes, 5 credits, refunded if it fails: atris youtube process \"$URL\"" >&2
     exit 2
   fi
 fi
@@ -150,10 +241,12 @@ fi
 # Leftover clean.txt is already cleaned; do not overwrite it with an empty VTT pass.
 if [ -n "$VTT" ]; then
 sed -E 's/<[^>]*>//g; s/&gt;/>/g; s/&amp;/\&/g; s/&quot;/"/g' "$VTT" | awk '
-function seconds(ts, parts) {
-  split(ts, parts, ":")
+function seconds(ts, parts, n) {
+  n = split(ts, parts, ":")
+  if (n == 2) return (parts[1] * 60) + int(parts[2])
   return (parts[1] * 3600) + (parts[2] * 60) + int(parts[3])
 }
+BEGIN { last_bucket = -1 }
 /^(WEBVTT|Kind:|Language:)/ { next }
 /-->/ { cue_seconds = seconds($1); next }
 {
@@ -184,7 +277,7 @@ fi
 
 TRANSCRIPT=$(<"yt_${ID}.clean.txt")
 
-STYLE_PROMPT="Write one-screen tweet-feed notes on this YouTube transcript ($INFO). Markdown only, start with # title then a 'Channel · Duration' line, 6-8 beats each opening with a **Bold hook.**, 4-6 verbatim quotes in double quotes with [mm:ss] timestamps on their own '> ' lines, end with a 2-item **Takeaway**. No preamble, no em dashes, fits one screen."
+STYLE_PROMPT="Write one-screen tweet-feed notes on this YouTube transcript ($INFO). Markdown only, start with # title then a 'Channel · Duration' line, 6-8 beats each opening with a **Bold hook.**, 4-6 verbatim quotes, each on its own line shaped exactly > \"quote\" [mm:ss], end with a 2-item **Takeaway**. No preamble, no em dashes, fits one screen."
 
 PROMPT="$STYLE_PROMPT
 
@@ -194,7 +287,7 @@ $TRANSCRIPT"
 run_with_timeout() {
   local seconds="$1"
   shift
-  perl -e '$seconds = shift @ARGV; alarm $seconds; exec @ARGV' "$seconds" "$@"
+  perl -e '$seconds = shift @ARGV; alarm $seconds; exec @ARGV or do { print STDERR "$ARGV[0]: not installed\n"; exit 127 }' "$seconds" "$@"
 }
 
 run_atris_fast() {
@@ -282,27 +375,80 @@ run_haiku() {
   run_with_timeout 240 claude -p "$PROMPT" --model claude-haiku-4-5
 }
 
+# Gemini Flash through the Antigravity CLI (agy). On an 85-minute transcript it
+# writes notes in about 8s; Haiku takes 30-40s. The old gemini CLI is retired.
+run_gemini() {
+  command -v agy >/dev/null 2>&1 || { echo "agy is not installed" >&2; return 127; }
+  run_with_timeout 120 agy -p "$PROMPT" --model "${ATRIS_YTNOTES_GEMINI_MODEL:-gemini-3.8-flash}" \
+    --effort low --print-timeout 110s </dev/null
+}
+
+# Fastest installed writer that answers: Gemini, Haiku, Codex, Cursor.
+# Buffered so a failed or empty answer never reaches the notes file.
+AUTO_WRITERS="agy:Gemini claude:Haiku codex:Codex cursor-agent:Cursor"
+
+run_writer() {
+  case "$1" in
+    agy) run_gemini ;;
+    claude) run_haiku ;;
+    codex) run_with_timeout 240 codex exec --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
+    cursor-agent) run_with_timeout 240 cursor-agent --trust -p "$PROMPT" ;;
+  esac
+}
+
+run_auto() {
+  local entry cmd label out tried=""
+  for entry in $AUTO_WRITERS; do
+    cmd="${entry%%:*}"
+    label="${entry#*:}"
+    command -v "$cmd" >/dev/null 2>&1 || continue
+    if [ -n "$tried" ]; then
+      echo "$tried did not answer; writing the notes with $label instead." >&2
+    fi
+    if out=$(run_writer "$cmd" 2>>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
+      printf '%s\n' "$out"
+      echo "notes by $label" >&2
+      return 0
+    fi
+    tried="$label"
+  done
+  if [ -n "$tried" ]; then
+    echo "$tried did not answer, and no other AI writer is installed." >&2
+  else
+    echo "No AI writer is installed on this computer. Install one of: Claude Code (claude), Antigravity (agy), Codex (codex), Cursor (cursor-agent)." >&2
+  fi
+  return 3
+}
+
 {
   case "$ENGINE" in
+    auto)
+      run_auto
+      ;;
     haiku)
       run_haiku
       ;;
     atris-fast|fast|atris)
       run_atris_fast
       ;;
-    gemini|gemini-3.7-flash)
-      run_with_timeout 120 gemini -m gemini-3.7-flash --skip-trust \
-        --approval-mode plan -o text -p "$PROMPT"
-      ;;
-    gemini-3.6-flash)
-      run_with_timeout 120 gemini -m gemini-3.6-flash --skip-trust \
-        --approval-mode plan -o text -p "$PROMPT"
+    gemini|agy)
+      run_gemini
       ;;
     grok)   run_grok ;;
-    codex)  run_with_timeout 240 codex exec --sandbox read-only --skip-git-repo-check "$PROMPT" </dev/null ;;
-    cursor) run_with_timeout 240 cursor-agent --trust -p "$PROMPT" ;;
-    *) echo "unknown engine: $ENGINE (haiku|atris-fast|gemini|grok|codex|cursor)" >&2; exit 1 ;;
+    codex)  run_writer codex ;;
+    cursor) run_writer cursor-agent ;;
+    *) echo "unknown engine: $ENGINE (auto|gemini|haiku|atris-fast|grok|codex|cursor)" >&2; exit 1 ;;
   esac
-} | perl -0pe 's/\A.*?(?=# )//s' | tee "yt_${ID}.md"
+} | perl -0pe 's/\A.*?(?=# )//s' > "yt_${ID}.md" || true
+
+if ! grep -q '[[:alnum:]]' "yt_${ID}.md"; then
+  rm -f "yt_${ID}.md"
+  echo "No notes were written. The transcript is saved at $WORK/yt_${ID}.clean.txt" >&2
+  echo "Paid notes, 5 credits, refunded if it fails: atris youtube process \"$URL\"" >&2
+  exit 3
+fi
+# auto names its writer above; a pinned engine is named here.
+[ "$ENGINE" = "auto" ] || echo "notes by $ENGINE" >&2
+cat "yt_${ID}.md"
 
 node "$SCRIPT_DIR/ytquote-repair.js" "yt_${ID}.md" "yt_${ID}.clean.txt"

package/scripts/det/ytquote-repair.js

@@ -7,7 +7,9 @@
 
 const fs = require('node:fs');
 
+// Models put the timestamp on either side: > "quote" [mm:ss] or > [mm:ss] "quote".
 const QUOTE_LINE = /^(\s*>\s*)(["“])(.+?)(["”])(\s*\[(\d{1,2}:\d{2}(?::\d{2})?)\])\s*$/;
+const QUOTE_LINE_TIME_FIRST = /^(\s*>\s*\[(\d{1,2}:\d{2}(?::\d{2})?)\]\s*)(["“])(.+?)(["”])\s*$/;
 const ANCHOR_LINE = /^\[(\d{1,2}:\d{2}(?::\d{2})?)\]\s*$/;
 const NEAR_SEC = 60;
 const OVERLAP_MIN = 0.6;
@@ -30,6 +32,18 @@ function parseTimestamp(ts) {
   return null;
 }
 
+function parseQuoteLine(line) {
+  const after = line.match(QUOTE_LINE);
+  if (after) {
+    return { quote: after[3], time: after[6], rebuild: (text) => `${after[1]}"${text}"${after[5]}` };
+  }
+  const first = line.match(QUOTE_LINE_TIME_FIRST);
+  if (first) {
+    return { quote: first[4], time: first[2], rebuild: (text) => `${first[1]}"${text}"` };
+  }
+  return null;
+}
+
 function probeHits(quote, flatTranscript) {
   const words = normalizeText(quote).split(' ').filter(Boolean);
   const probe = words.slice(0, Math.min(6, words.length)).join(' ');
@@ -112,20 +126,20 @@ function repairNotes(notes, transcript) {
   let dropped = 0;
 
   for (const line of lines) {
-    const match = line.match(QUOTE_LINE);
+    const match = parseQuoteLine(line);
     if (!match) {
       out.push(line);
       continue;
     }
 
-    const quote = match[3];
+    const quote = match.quote;
     if (probeHits(quote, flat)) {
       out.push(line);
       kept += 1;
       continue;
     }
 
-    const time = parseTimestamp(match[6]);
+    const time = parseTimestamp(match.time);
     const quoteWords = normalizeText(quote).split(' ').filter(Boolean);
     const repairedText = time == null ? null : bestWindow(quoteWords, nearbyWords(segments, time));
     if (!repairedText) {
@@ -133,7 +147,7 @@ function repairNotes(notes, transcript) {
       continue;
     }
 
-    out.push(`${match[1]}"${repairedText}"${match[5]}`);
+    out.push(match.rebuild(repairedText));
     repaired += 1;
   }
 

package/scripts/det/ytrail-bench.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+'use strict';
+
+// Bench what users get from `atris youtube notes`, end to end, uncached.
+// Usage: node scripts/det/ytrail-bench.js [--quick] [--case <name>]
+// Prints one line per case and a final "bench: X/Y passed in Ns"; exits 1 if
+// any case fails. Rows (with a `case` field) go to $YTRAIL_OUT_DIR/ytrail.jsonl,
+// default ~/.atris/benchmarks, outside any git repo.
+// ytnotes is resolved next to this file, so an installed copy benches itself.
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { evaluate, appendRow } = require('./ytrail-eval');
+
+const YTNOTES = path.join(__dirname, 'ytnotes');
+const STRANGER_TIMEOUT_MS = 300000;
+
+const CASES = [
+  { name: 'captioned-short', kind: 'graded', url: 'https://www.youtube.com/watch?v=Z3JyAqh4ixg', quick: true },
+  { name: 'captioned-long', kind: 'graded', url: 'https://www.youtube.com/watch?v=Am7IWP8IpEc' },
+  { name: 'no-captions', kind: 'no-captions', url: 'https://www.youtube.com/watch?v=6DRlX5vIOE0', minWords: 50 },
+  { name: 'stranger-no-downloader', kind: 'no-downloader', url: 'https://www.youtube.com/watch?v=Am7IWP8IpEc', quick: true },
+  { name: 'stranger-no-writer', kind: 'no-writer', url: 'https://www.youtube.com/watch?v=Am7IWP8IpEc', quick: true },
+];
+
+function parseArgs(argv) {
+  const opts = { quick: false, only: null };
+  for (let i = 0; i < argv.length; i += 1) {
+    if (argv[i] === '--quick') opts.quick = true;
+    else if (argv[i] === '--case') opts.only = argv[++i] || '';
+    else if (argv[i].startsWith('--case=')) opts.only = argv[i].slice('--case='.length);
+    else throw new Error(`unknown option: ${argv[i]}`);
+  }
+  return opts;
+}
+
+function selectCases(opts, cases = CASES) {
+  if (opts.only !== null) {
+    const found = cases.filter((c) => c.name === opts.only);
+    if (!found.length) {
+      throw new Error(`unknown case: ${opts.only} (cases: ${cases.map((c) => c.name).join(', ')})`);
+    }
+    return found;
+  }
+  return opts.quick ? cases.filter((c) => c.quick) : cases.slice();
+}
+
+// First executable named `name` on PATH, then in the extra dirs.
+function findBinary(name, env = process.env, extraDirs = []) {
+  const dirs = String(env.PATH || '').split(path.delimiter).filter(Boolean).concat(extraDirs);
+  for (const dir of dirs) {
+    const file = path.join(dir, name);
+    try {
+      fs.accessSync(file, fs.constants.X_OK);
+      if (fs.statSync(file).isFile()) return file;
+    } catch {}
+  }
+  return null;
+}
+
+function findWhisper(env = process.env) {
+  return findBinary('mlx_whisper', env, [path.join(os.homedir(), '.local', 'bin')]);
+}
+
+function findYtDlp(env = process.env) {
+  return findBinary('yt-dlp', env, [path.join(os.homedir(), '.local', 'bin'), '/opt/homebrew/bin']);
+}
+
+// Pure pass/fail rules. Each takes a finished run and returns { pass, note }.
+function judgeNoCaptions({ whisper, row, stderr }) {
+  if (whisper) {
+    return { pass: Boolean(row.pass), note: 'local transcription' };
+  }
+  const pass = row.exit === 2 && /atris youtube process/.test(stderr || '');
+  return { pass, note: 'no speech model, paid command offered' };
+}
+
+function judgeNoDownloader({ status, stderr }) {
+  const text = String(stderr || '');
+  const pass = status === 2 && /missing yt-dlp/.test(text) && !/No English captions/.test(text);
+  return { pass, note: pass ? 'says to install yt-dlp' : 'did not say to install yt-dlp' };
+}
+
+function judgeNoWriter({ status, stderr, notesLeft }) {
+  const text = String(stderr || '');
+  const pass = status === 3 && /No AI writer is installed/.test(text) && !notesLeft;
+  return { pass, note: pass ? 'says to install an AI writer' : 'did not say to install an AI writer' };
+}
+
+// Run ytnotes as a stranger would: a bare HOME, and only node (plus yt-dlp
+// when given) on top of the system dirs.
+function runStranger(url, { ytDlp = null } = {}) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ytrail-stranger-'));
+  const bin = path.join(tmp, 'bin');
+  fs.mkdirSync(bin);
+  fs.symlinkSync(process.execPath, path.join(bin, 'node'));
+  if (ytDlp) fs.symlinkSync(ytDlp, path.join(bin, 'yt-dlp'));
+  try {
+    const started = Date.now();
+    const run = spawnSync(YTNOTES, [url], {
+      encoding: 'utf8',
+      cwd: tmp,
+      env: { HOME: tmp, PATH: `${bin}:/usr/bin:/bin`, TMPDIR: tmp },
+      timeout: STRANGER_TIMEOUT_MS,
+    });
+    const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
+    const id = String(url).match(/[?&]v=([^&]+)/)[1];
+    const notesLeft = fs.existsSync(path.join(tmp, 'ytnotes', `yt_${id}.md`));
+    return { status: run.status, stderr: String(run.stderr || ''), seconds, notesLeft };
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+function lastLines(text, n = 3) {
+  return String(text || '').trim().split('\n').filter(Boolean).slice(-n).map((line) => `  ${line}`).join('\n');
+}
+
+function runCase(c) {
+  if (c.kind === 'graded' || c.kind === 'no-captions') {
+    const whisper = c.kind === 'no-captions' ? findWhisper() : null;
+    const { row, stderr } = evaluate({ url: c.url, engine: 'auto', minWords: c.minWords });
+    let verdict = { pass: row.pass, note: null };
+    if (c.kind === 'no-captions') verdict = judgeNoCaptions({ whisper, row, stderr });
+    const q = row.quotes;
+    const parts = [
+      `${c.name} ${verdict.pass ? 'pass' : 'fail'} ${row.seconds}s`,
+      verdict.note ? `(${verdict.note})` : null,
+      `exit=${row.exit === null ? 'none' : row.exit}`,
+      `words=${row.words}`,
+      `writer=${row.writer || 'none'}`,
+      q ? `quotes=${q.kept} kept/${q.repaired} repaired/${q.dropped} dropped` : null,
+    ].filter(Boolean);
+    return {
+      pass: verdict.pass,
+      line: parts.join(' '),
+      detail: verdict.pass ? '' : lastLines(stderr),
+      row: { ...row, case: c.name, pass: verdict.pass, ...(verdict.note ? { path: verdict.note } : {}) },
+    };
+  }
+
+  let ytDlp = null;
+  if (c.kind === 'no-writer') {
+    ytDlp = findYtDlp();
+    if (!ytDlp) {
+      return {
+        skipped: true,
+        line: `${c.name} skipped: no yt-dlp on this computer to test with`,
+        row: { ts: new Date().toISOString(), case: c.name, url: c.url, skipped: true },
+      };
+    }
+  }
+  const run = runStranger(c.url, { ytDlp });
+  const verdict = c.kind === 'no-writer' ? judgeNoWriter(run) : judgeNoDownloader(run);
+  return {
+    pass: verdict.pass,
+    line: `${c.name} ${verdict.pass ? 'pass' : 'fail'} ${run.seconds}s exit=${run.status === null ? 'none' : run.status} (${verdict.note})`,
+    detail: verdict.pass ? '' : lastLines(run.stderr),
+    row: {
+      ts: new Date().toISOString(),
+      case: c.name,
+      url: c.url,
+      seconds: run.seconds,
+      pass: verdict.pass,
+      exit: run.status,
+      notesLeft: run.notesLeft,
+    },
+  };
+}
+
+function summary(results, seconds) {
+  const ran = results.filter((r) => !r.skipped);
+  const passed = ran.filter((r) => r.pass).length;
+  const skipped = results.length - ran.length;
+  return `bench: ${passed}/${ran.length} passed in ${seconds}s${skipped ? ` (${skipped} skipped)` : ''}`;
+}
+
+function main() {
+  let cases;
+  try {
+    cases = selectCases(parseArgs(process.argv.slice(2)));
+  } catch (err) {
+    console.error(err.message);
+    console.error('usage: ytrail-bench [--quick] [--case <name>]');
+    process.exit(2);
+  }
+  const outDir = process.env.YTRAIL_OUT_DIR || path.join(os.homedir(), '.atris', 'benchmarks');
+  const started = Date.now();
+  const results = [];
+  for (const c of cases) {
+    const result = runCase(c);
+    results.push(result);
+    console.log(result.line);
+    if (result.detail) console.log(result.detail);
+    appendRow(outDir, result.row);
+  }
+  console.log(summary(results, Math.round((Date.now() - started) / 1000)));
+  process.exit(results.some((r) => !r.skipped && !r.pass) ? 1 : 0);
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  CASES,
+  parseArgs,
+  selectCases,
+  findBinary,
+  judgeNoCaptions,
+  judgeNoDownloader,
+  judgeNoWriter,
+  summary,
+};