atris 3.46.1 → 3.48.0

package/scripts/det/text.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+// det/text.js — deterministic line-and-word chores an LLM gets asked to eyeball
+// (and miscounts). Reads text on stdin, writes stdout.
+//
+// Usage:
+//   cat list.txt | node text.js dedupe        # drop duplicate lines, keep first order
+//   node text.js sort   < list.txt            # sort lines (byte order)
+//   node text.js rsort  < list.txt            # reverse sort
+//   node text.js count  < list.txt            # lines / words / chars, one metric per line
+//   node text.js slug   < title.txt           # each line -> url slug
+//   node text.js trim   < messy.txt           # strip trailing ws, drop blank lines
+//
+// Modes: dedupe | sort | rsort | count | slug | trim
+// Exit 0 on success, 2 on bad mode.
+
+'use strict';
+
+function splitLines(input) {
+  // Normalize CRLF, drop a single trailing newline so "a\nb\n" is 2 lines not 3.
+  const t = input.replace(/\r\n/g, '\n').replace(/\n$/, '');
+  return t === '' ? [] : t.split('\n');
+}
+
+function slugify(s) {
+  return s
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '') // strip accents
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-') // non-alphanumeric -> hyphen
+    .replace(/^-+|-+$/g, ''); // trim leading/trailing hyphens
+}
+
+// Pure core: returns { text } or { error }. Unit-testable without process I/O.
+function run(mode, input) {
+  const lines = splitLines(input);
+  switch (mode) {
+    case 'dedupe': {
+      const seen = new Set();
+      const out = [];
+      for (const l of lines) {
+        if (!seen.has(l)) {
+          seen.add(l);
+          out.push(l);
+        }
+      }
+      return { text: out.join('\n') };
+    }
+    case 'sort':
+      return { text: [...lines].sort().join('\n') };
+    case 'rsort':
+      return { text: [...lines].sort().reverse().join('\n') };
+    case 'count': {
+      const words = (input.match(/\S+/g) || []).length;
+      const chars = input.replace(/\n$/, '').length;
+      return { text: `lines\t${lines.length}\nwords\t${words}\nchars\t${chars}` };
+    }
+    case 'slug':
+      return { text: lines.map(slugify).join('\n') };
+    case 'trim':
+      return {
+        text: lines
+          .map((l) => l.replace(/\s+$/, ''))
+          .filter((l) => l.trim() !== '')
+          .join('\n'),
+      };
+    default:
+      return { error: `unknown mode: ${mode}` };
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    if (process.stdin.isTTY) resolve('');
+  });
+}
+
+const MODES = ['dedupe', 'sort', 'rsort', 'count', 'slug', 'trim'];
+
+async function main() {
+  const mode = process.argv.slice(2).find((a) => !a.startsWith('-'));
+  if (!mode || !MODES.includes(mode)) {
+    process.stderr.write(`unknown mode: ${mode || '(none)'}\nmodes: ${MODES.join(' | ')}\n`);
+    process.exit(2);
+  }
+  const input = await readStdin();
+  const res = run(mode, input);
+  if (res.error) {
+    process.stderr.write(res.error + '\n');
+    process.exit(2);
+  }
+  if (res.text.length) process.stdout.write(res.text + '\n');
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { run, slugify, MODES };

package/scripts/det/voice.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// det/voice.js - score a chat reply against the way of talking (atris.md ## voice).
+// Deterministic: same input, same verdict. Used by the engine voice exam and any
+// agent that wants to check its own reply before sending it to a human.
+//
+//   node det.js voice scan < reply.txt      # PASS, or FAIL with one finding per line
+//   node det.js voice json < reply.txt      # machine-readable findings
+
+'use strict';
+
+const MODES = ['scan', 'json'];
+
+// Code fences, inline code, and markdown link targets stay literal on purpose:
+// the standard allows one copyable command and real references inside backticks.
+function stripLiterals(text) {
+  return String(text || '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`[^`\n]*`/g, ' ')
+    .replace(/\]\([^)]*\)/g, '] ');
+}
+
+const RULES = [
+  ['em-dash', /—/g],
+  ['task-code', /\b[A-Z]{2,10}-\d{1,6}\b/g],
+  ['raw-id', /\b[0-9A-HJKMNP-TV-Z]{26}\b/g],
+  ['system-noun', /\b(?:task plane|mission spine|second reviewer|worktrees?|verifiers?|orchestrat\w*|subagents?|ULIDs?|projections?)\b/gi],
+];
+
+function isHexHash(word) {
+  return /^[0-9a-f]{7,40}$/.test(word) && /\d/.test(word) && /[a-f]/.test(word);
+}
+
+function scanReply(text) {
+  const clean = stripLiterals(text);
+  const findings = [];
+  for (const [rule, pattern] of RULES) {
+    for (const match of clean.match(pattern) || []) {
+      findings.push({ rule, snippet: match === '—' ? 'U+2014' : match });
+    }
+  }
+  for (const match of clean.match(/\b[0-9a-f]{7,40}\b/g) || []) {
+    if (isHexHash(match)) findings.push({ rule: 'commit-hash', snippet: match });
+  }
+  const bullets = (clean.match(/^\s*[-*•] /gm) || []).length;
+  if (bullets > 3) findings.push({ rule: 'bullet-stack', snippet: `${bullets} bullets` });
+  const seen = new Set();
+  return findings.filter((f) => {
+    const key = `${f.rule}:${f.snippet}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function run(mode, input) {
+  if (!MODES.includes(mode)) return { error: `unknown mode: ${mode || '(none)'}` };
+  const findings = scanReply(input);
+  if (mode === 'json') return { text: JSON.stringify({ pass: findings.length === 0, findings }) };
+  if (!findings.length) return { text: 'PASS' };
+  return {
+    text: [`FAIL (${findings.length})`, ...findings.map((f) => `- ${f.rule}: "${f.snippet}"`)].join('\n'),
+  };
+}
+
+if (require.main === module) {
+  let data = '';
+  process.stdin.on('data', (chunk) => { data += chunk; });
+  process.stdin.on('end', () => {
+    const result = run(process.argv[2] || 'scan', data);
+    if (result.error) { process.stderr.write(`${result.error}\n`); process.exit(2); }
+    process.stdout.write(`${result.text}\n`);
+    process.exit(result.text.startsWith('PASS') || result.text.startsWith('{"pass":true') ? 0 : 1);
+  });
+}
+
+module.exports = { run, scanReply, MODES };

package/scripts/det/ytnotes

@@ -0,0 +1,196 @@
+#!/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.
+# 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]"
+
+case "${1:-}" in
+  *youtube.com*|*youtu.be*) ;;
+  *) echo "$USAGE" >&2; exit 2 ;;
+esac
+
+URL="$1"
+ENGINE="${2:-haiku}"
+CALLER_CWD="$PWD"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+WORK="${TMPDIR:-/tmp}/ytnotes"
+mkdir -p "$WORK"
+cd "$WORK"
+
+META=$(yt-dlp --no-update --quiet --no-warnings --skip-download \
+  --write-auto-subs --sub-format vtt --sub-langs en \
+  --no-simulate \
+  -o "yt_%(id)s" \
+  --print "%(id)s|%(title)s|%(channel)s|%(duration_string)s" \
+  "$URL" 2>/dev/null)
+ID="${META%%|*}"
+INFO="${META#*|}"
+
+VTT="yt_${ID}.en.vtt"
+if [ ! -s "$VTT" ]; then
+  echo "No English captions found for $URL. Falling back is manual (atris youtube process, 5 credits)." >&2
+  exit 2
+fi
+
+# Strip VTT cruft, drop only nearby rolling-caption duplicates, and keep one
+# time anchor every 30 seconds. Raw auto-captions are mostly timestamp spam:
+# the 21-minute canary is 210 KB raw, 95 KB with the old cleaner, and 22 KB here.
+sed -E 's/<[^>]*>//g; s/&gt;/>/g; s/&amp;/\&/g; s/&quot;/"/g' "$VTT" | awk '
+function seconds(ts, parts) {
+  split(ts, parts, ":")
+  return (parts[1] * 3600) + (parts[2] * 60) + int(parts[3])
+}
+/^(WEBVTT|Kind:|Language:)/ { next }
+/-->/ { cue_seconds = seconds($1); next }
+{
+  line = $0
+  gsub(/^[[:space:]]+|[[:space:]]+$/, "", line)
+  if (line == "") next
+
+  duplicate = 0
+  for (i = 0; i < 6; i++) if (recent[i] == line) duplicate = 1
+  if (duplicate) next
+
+  bucket = int(cue_seconds / 30)
+  if (bucket != last_bucket) {
+    total = int(cue_seconds)
+    hours = int(total / 3600)
+    minutes = int((total % 3600) / 60)
+    secs = total % 60
+    if (hours > 0) printf "[%02d:%02d:%02d]\n", hours, minutes, secs
+    else printf "[%02d:%02d]\n", minutes, secs
+    last_bucket = bucket
+  }
+
+  print line
+  for (i = 5; i > 0; i--) recent[i] = recent[i - 1]
+  recent[0] = line
+}' > "yt_${ID}.clean.txt"
+
+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."
+
+PROMPT="$STYLE_PROMPT
+
+Transcript:
+$TRANSCRIPT"
+
+run_with_timeout() {
+  local seconds="$1"
+  shift
+  perl -e '$seconds = shift @ARGV; alarm $seconds; exec @ARGV' "$seconds" "$@"
+}
+
+run_atris_fast() {
+  if [ ! -d "$CALLER_CWD/atris" ]; then
+    echo "atris-fast requires ytnotes to run from an initialized Atris workspace" >&2
+    return 2
+  fi
+
+  local jobs_file="$WORK/yt_${ID}.jobs.json"
+  local map_raw
+
+  node - "$INFO" "$WORK/yt_${ID}.clean.txt" "$jobs_file" <<'NODE'
+const fs = require('fs')
+const info = process.argv[2]
+const transcriptPath = process.argv[3]
+const jobsPath = process.argv[4]
+const lines = fs.readFileSync(transcriptPath, 'utf8').trim().split('\n')
+const targetBytes = 11000
+const chunks = []
+let current = []
+let bytes = 0
+
+for (const line of lines) {
+  const lineBytes = Buffer.byteLength(`${line}\n`)
+  if (current.length && bytes + lineBytes > targetBytes) {
+    chunks.push(current.join('\n'))
+    current = []
+    bytes = 0
+  }
+  current.push(line)
+  bytes += lineBytes
+}
+if (current.length) chunks.push(current.join('\n'))
+
+const jobs = chunks.map((chunk, index) => ({
+  engine: 'atris-fast',
+  label: `chunk-${String(index + 1).padStart(2, '0')}`,
+  prompt: `Read-only transcript analysis. Do not call tools. This is ordered chunk ${index + 1} of ${chunks.length} from ${info}. Return only valid JSON with this exact shape: {"beats":[{"time":"mm:ss","hook":"max 8 words","detail":"max 18 words"}],"action":"max 14 words"}. Pick exactly 3 critical beats. Prefer concrete names, numbers, mechanisms, and honest uncertainty; paraphrase instead of quoting. No markdown or preamble.\n\n${chunk}`,
+}))
+
+fs.writeFileSync(jobsPath, JSON.stringify(jobs))
+NODE
+
+  map_raw=$(cd "$CALLER_CWD" && atris engine ask --jobs "$jobs_file" \
+    --concurrency 3 --timeout 15 --json)
+  printf '%s' "$map_raw" | node -e '
+let raw = ""
+process.stdin.on("data", (chunk) => { raw += chunk })
+process.stdin.on("end", () => {
+  const receipt = JSON.parse(raw)
+  const answers = [...(receipt.answers || [])].sort((a, b) => a.label.localeCompare(b.label))
+  if (!answers.length || answers.some((answer) => !answer.ok)) process.exit(2)
+
+  const titleParts = process.argv[1].split("|")
+  const beats = []
+  const actions = []
+  for (const answer of answers) {
+    let output = answer.stdout
+    try { output = JSON.parse(answer.stdout).output || output } catch {}
+    const clean = String(output).trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "")
+    let parsed
+    try { parsed = JSON.parse(clean) } catch { process.exit(2) }
+    for (const beat of (parsed.beats || []).slice(0, 3)) beats.push(beat)
+    if (parsed.action) actions.push(String(parsed.action))
+  }
+  if (beats.length < 4) process.exit(2)
+
+  const lines = [`# ${titleParts[0]}`, `${titleParts[1] || "YouTube"} · ${titleParts[2] || ""}`]
+  for (const beat of beats.slice(0, 6)) {
+    const hook = String(beat.hook || "Key idea").replace(/[.]+$/, "")
+    const time = String(beat.time || "").replace(/^\[|\]$/g, "")
+    lines.push("", `**${hook}.**`, `${String(beat.detail || "").trim()}${time ? ` [${time}]` : ""}`)
+  }
+  lines.push("", "**Takeaway**", "", `1. ${actions[0] || "Apply the strongest mechanism to one current Atris mission."}`, `2. ${actions[1] || "Require one proof artifact before that mission advances."}`)
+  process.stdout.write(`${lines.join("\n").trim()}\n`)
+})' "$INFO"
+}
+
+run_grok() {
+  run_with_timeout 240 grok --verbatim --no-memory --no-plan --no-subagents \
+    --disable-web-search --max-turns 1 -p "$PROMPT"
+}
+
+run_haiku() {
+  run_with_timeout 240 claude -p "$PROMPT" --model claude-haiku-4-5
+}
+
+{
+  case "$ENGINE" in
+    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"
+      ;;
+    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 ;;
+  esac
+} | perl -0pe 's/\A.*?(?=# )//s' | tee "yt_${ID}.md"
+
+node "$SCRIPT_DIR/ytquote-repair.js" "yt_${ID}.md" "yt_${ID}.clean.txt"

package/scripts/det/ytquote-repair.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+'use strict';
+
+// Replace paraphrased ytnotes quotes with nearby caption words, or drop them.
+// Usage: node ytquote-repair.js <notes.md> <clean-transcript.txt>
+// Always exits 0. Summary goes to stderr.
+
+const fs = require('node:fs');
+
+const QUOTE_LINE = /^(\s*>\s*)(["“])(.+?)(["”])(\s*\[(\d{1,2}:\d{2}(?::\d{2})?)\])\s*$/;
+const ANCHOR_LINE = /^\[(\d{1,2}:\d{2}(?::\d{2})?)\]\s*$/;
+const NEAR_SEC = 60;
+const OVERLAP_MIN = 0.6;
+const QUOTE_MAX = 240;
+
+function normalizeText(s) {
+  return String(s)
+    .toLowerCase()
+    .replace(/[‘’“”'"]/g, '')
+    .replace(/[^a-z0-9 ]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function parseTimestamp(ts) {
+  const parts = String(ts).split(':').map(Number);
+  if (!parts.length || parts.some((n) => Number.isNaN(n))) return null;
+  if (parts.length === 2) return parts[0] * 60 + parts[1];
+  if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+  return null;
+}
+
+function probeHits(quote, flatTranscript) {
+  const words = normalizeText(quote).split(' ').filter(Boolean);
+  const probe = words.slice(0, Math.min(6, words.length)).join(' ');
+  return Boolean(probe && flatTranscript.includes(probe));
+}
+
+function parseTranscript(text) {
+  const segments = [];
+  let current = null;
+  for (const line of String(text).split(/\r?\n/)) {
+    const anchor = line.match(ANCHOR_LINE);
+    if (anchor) {
+      if (current) segments.push(current);
+      current = { time: parseTimestamp(anchor[1]), words: [] };
+      continue;
+    }
+    if (!current) continue;
+    for (const word of line.trim().split(/\s+/).filter(Boolean)) {
+      current.words.push(word);
+    }
+  }
+  if (current) segments.push(current);
+  return segments;
+}
+
+function nearbyWords(segments, time) {
+  const words = [];
+  for (const seg of segments) {
+    if (seg.time == null || Math.abs(seg.time - time) > NEAR_SEC) continue;
+    words.push(...seg.words);
+  }
+  return words;
+}
+
+function wordOverlap(quoteWords, windowWords) {
+  const windowSet = new Set(windowWords.filter(Boolean));
+  let hit = 0;
+  for (const word of quoteWords) {
+    if (word && windowSet.has(word)) hit += 1;
+  }
+  return quoteWords.length ? hit / quoteWords.length : 0;
+}
+
+function bestWindow(quoteWords, sourceExact) {
+  const n = quoteWords.length;
+  if (!n || !sourceExact.length) return null;
+
+  const sourceNorm = sourceExact.map((word) => normalizeText(word));
+  const limit = Math.max(1, sourceExact.length - n + 1);
+  let bestScore = -1;
+  let bestExact = '';
+
+  for (let i = 0; i < limit; i += 1) {
+    const size = Math.min(n, sourceExact.length - i);
+    const score = wordOverlap(quoteWords, sourceNorm.slice(i, i + size));
+    if (score > bestScore) {
+      bestScore = score;
+      bestExact = sourceExact.slice(i, i + size).join(' ');
+    }
+  }
+
+  if (bestScore < OVERLAP_MIN) return null;
+  return bestExact.length > QUOTE_MAX ? bestExact.slice(0, QUOTE_MAX).trim() : bestExact;
+}
+
+function repairNotes(notes, transcript) {
+  const flat = normalizeText(transcript);
+  const segments = parseTranscript(transcript);
+  const nl = String(notes).includes('\r\n') ? '\r\n' : '\n';
+  const raw = String(notes);
+  const hadTrailing = /[\r\n]$/.test(raw);
+  const lines = raw.replace(/\r\n/g, '\n').replace(/\n$/, '').split('\n');
+  if (lines.length === 1 && lines[0] === '' && raw === '') {
+    return { text: '', kept: 0, repaired: 0, dropped: 0 };
+  }
+
+  const out = [];
+  let kept = 0;
+  let repaired = 0;
+  let dropped = 0;
+
+  for (const line of lines) {
+    const match = line.match(QUOTE_LINE);
+    if (!match) {
+      out.push(line);
+      continue;
+    }
+
+    const quote = match[3];
+    if (probeHits(quote, flat)) {
+      out.push(line);
+      kept += 1;
+      continue;
+    }
+
+    const time = parseTimestamp(match[6]);
+    const quoteWords = normalizeText(quote).split(' ').filter(Boolean);
+    const repairedText = time == null ? null : bestWindow(quoteWords, nearbyWords(segments, time));
+    if (!repairedText) {
+      dropped += 1;
+      continue;
+    }
+
+    out.push(`${match[1]}"${repairedText}"${match[5]}`);
+    repaired += 1;
+  }
+
+  let text = out.join(nl);
+  if (hadTrailing || raw.length) text += nl;
+  return { text, kept, repaired, dropped };
+}
+
+function main() {
+  const notesPath = process.argv[2];
+  const transcriptPath = process.argv[3];
+  let kept = 0;
+  let repaired = 0;
+  let dropped = 0;
+
+  try {
+    if (notesPath && transcriptPath && fs.existsSync(notesPath)) {
+      const notes = fs.readFileSync(notesPath, 'utf8');
+      const transcript = fs.existsSync(transcriptPath)
+        ? fs.readFileSync(transcriptPath, 'utf8')
+        : '';
+      const result = repairNotes(notes, transcript);
+      fs.writeFileSync(notesPath, result.text);
+      kept = result.kept;
+      repaired = result.repaired;
+      dropped = result.dropped;
+    }
+  } catch {
+    kept = 0;
+    repaired = 0;
+    dropped = 0;
+  }
+
+  console.error(`quotes: ${kept} kept, ${repaired} repaired, ${dropped} dropped`);
+  process.exit(0);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  normalizeText,
+  repairNotes,
+};

package/scripts/det/ytrail-eval.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+'use strict';
+
+// Score one ytnotes run. Usage:
+//   node scripts/det/ytrail-eval.js [url] [engine]
+// Default url: https://www.youtube.com/watch?v=Z3JyAqh4ixg
+// Default engine: haiku
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_URL = 'https://www.youtube.com/watch?v=Z3JyAqh4ixg';
+const DEFAULT_ENGINE = 'haiku';
+
+function videoId(url) {
+  const watch = String(url).match(/[?&]v=([^&]+)/);
+  if (watch) return watch[1];
+  const short = String(url).match(/youtu\.be\/([^?&/]+)/);
+  return short ? short[1] : null;
+}
+
+function wordCount(text) {
+  return String(text).trim().split(/\s+/).filter(Boolean).length;
+}
+
+function norm(s) {
+  return String(s)
+    .toLowerCase()
+    .replace(/[‘’“”'"]/g, '')
+    .replace(/[^a-z0-9 ]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function scoreQuotes(notes, transcript) {
+  const flat = norm(transcript);
+  const spans = [...String(notes).matchAll(/[“"]([^“”"]{15,240})[”"]/g)]
+    .map((m) => m[1])
+    .slice(0, 8);
+  let ok = 0;
+  for (const q of spans) {
+    const words = norm(q).split(' ').filter(Boolean);
+    const probe = words.slice(0, Math.min(6, words.length)).join(' ');
+    if (probe && flat.includes(probe)) ok += 1;
+  }
+  const needed = spans.length / 2;
+  return {
+    spans: spans.length,
+    verified: ok,
+    pass: spans.length >= 2 && ok >= needed,
+  };
+}
+
+function firstLine(text) {
+  return String(text).replace(/^\uFEFF/, '').split(/\r?\n/, 1)[0] || '';
+}
+
+function main() {
+  const url = process.argv[2] || DEFAULT_URL;
+  const engine = process.argv[3] || DEFAULT_ENGINE;
+  const root = path.resolve(__dirname, '..', '..');
+  const ytnotes = path.join(root, 'scripts', 'det', 'ytnotes');
+  const workDir = path.join(process.env.TMPDIR || '/tmp', 'ytnotes');
+  const id = videoId(url);
+  const transcriptPath = id ? path.join(workDir, `yt_${id}.clean.txt`) : '';
+  const notesPath = id ? path.join(workDir, `yt_${id}.md`) : '';
+
+  const started = Date.now();
+  const run = spawnSync(ytnotes, [url, engine], {
+    encoding: 'utf8',
+    cwd: root,
+    env: process.env,
+    timeout: 180000,
+  });
+  const seconds = Number(((Date.now() - started) / 1000).toFixed(1));
+
+  const stdoutNotes = String(run.stdout || '');
+  let fileNotes = '';
+  if (notesPath && fs.existsSync(notesPath)) {
+    fileNotes = fs.readFileSync(notesPath, 'utf8');
+  }
+  const notes = fileNotes || stdoutNotes;
+
+  let transcript = '';
+  if (transcriptPath && fs.existsSync(transcriptPath)) {
+    transcript = fs.readFileSync(transcriptPath, 'utf8');
+  }
+
+  const quotes = scoreQuotes(notes, transcript);
+  const checks = {
+    exit0: run.status === 0,
+    transcriptWords: wordCount(transcript) >= 1000,
+    notesExist: notes.trim().length > 0,
+    notesHeading: firstLine(notes).startsWith('#'),
+    quoteHonesty: quotes.pass,
+  };
+  const pass = Object.values(checks).every(Boolean);
+
+  const row = {
+    ts: new Date().toISOString(),
+    url,
+    engine,
+    seconds,
+    pass,
+    checks,
+  };
+
+  const outDir = path.join(root, 'atris', 'benchmarks');
+  fs.mkdirSync(outDir, { recursive: true });
+  fs.appendFileSync(path.join(outDir, 'ytrail.jsonl'), `${JSON.stringify(row)}\n`);
+
+  const words = wordCount(transcript);
+  console.log(
+    `ytrail ${pass ? 'pass' : 'fail'} ${engine} ${seconds}s words=${words} quotes=${quotes.verified}/${quotes.spans} heading=${checks.notesHeading ? 'yes' : 'no'}`
+  );
+  if (run.status !== 0 && run.stderr) {
+    console.log(String(run.stderr).trim().split('\n').slice(-8).join('\n'));
+  }
+
+  process.exit(pass ? 0 : 1);
+}
+
+main();