atris 3.47.0 → 3.48.0

package/atris/skills/youtube/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: youtube
-description: "Process YouTube videos — extract insights, answer questions, store as knowledge. 5 credits per video. Triggers on: youtube, video, process video, watch this, learn from video."
+description: "Process YouTube videos: extract insights, answer questions, store as knowledge. 5 credits per video. Triggers on: youtube, video, process video, watch this, learn from video."
 version: 2.3.0
 tags:
   - youtube
@@ -15,9 +15,11 @@ Process any YouTube video through Atris transcript-first analysis. The CLI extra
 
 ## Route first: learning vs product
 
-Two rails process YouTube videos — pick before running anything:
+Two rails process YouTube videos: pick before running anything:
 
 - **Learning / work rail** → use the `alpha-learn` skill (ytnotes). Local yt-dlp + grok, zero credits, podcastnotes-style notes, tweet-feed output, `[claimable]` entries in today's journal for other agents. Use this when the goal is to LEARN from a video or mine it for Atris work.
+  Canonical ytnotes source is `scripts/det/ytnotes` (install: `ln -sf "$PWD/scripts/det/ytnotes" ~/.local/bin/ytnotes`).
+  Runs are scored by `node scripts/det/ytrail-eval.js`.
 - **Product rail** → this skill (`atris youtube process`). Credits-billed, stores knowledge in the Atris backend, customer-facing path. Use this when a customer/agent needs the video stored as Atris knowledge or answered via the API.
 
 If the user says "learn from", "notes on", "alpha", or "rabbit hole" → alpha-learn. If they say "process", "store", "add to knowledge" → this skill.
@@ -189,7 +191,7 @@ Every important insight should carry a timestamp when the transcript provides on
 | `401` | Token expired/invalid | `atris login --force` |
 | `402` | Not enough credits | Check balance, purchase at atris.ai |
 | `400` | Invalid YouTube URL | Check URL format |
-| `502` | Transcript or cloud processing failed | Retry — credits auto-refunded when backend fails |
+| `502` | Transcript or cloud processing failed | Retry; credits auto-refunded when backend fails |
 
 ---
 

package/bin/atris.js

@@ -38,6 +38,7 @@ try {
 const {
   checkForUpdates,
   showUpdateNotification,
+  autoUpdate,
   inspectInstallGitState,
   formatInstallGitWarning,
 } = require('../utils/update-check');
@@ -106,6 +107,7 @@ if (!skipUpdateCheck && (!updateCommand || (updateCommand && !['version', 'updat
         showUpdateNotification(updateInfo, {
           packageRoot: path.join(__dirname, '..'),
         });
+        autoUpdate(updateInfo, { packageRoot: path.join(__dirname, '..') });
       }
       return updateInfo;
     })
@@ -569,7 +571,7 @@ function showHelp() {
   console.log('  router     - inspect ax lane outcomes and promote gated reflex overrides');
   console.log('  sign       - Co-author trailer on every commit in an atris workspace (on/off/status)');
   console.log('  visualize  - Generate a Slack/deck-ready visual from a prompt');
-  console.log('  youtube    - Process YouTube videos with timestamped transcript-first analysis');
+  console.log('  youtube    - Free local notes or 5-credit cloud process for YouTube videos');
   console.log('');
   console.log('Experiments:');
   console.log('  experiments init [slug]     - Prepare atris/experiments/ or scaffold a pack');

package/commands/mission.js

@@ -23,6 +23,7 @@ const {
 } = require('../lib/runner-command');
 const {
   resolveEngineForRoleWithPreference,
+  engineFailureHealthStatus,
   setEngineHealth,
 } = require('../lib/engine-registry');
 const {
@@ -378,28 +379,6 @@ function resolveMissionTickRunner(mission, root = process.cwd()) {
   };
 }
 
-function engineFailureHealthStatus(result) {
-  if (!result || result.status !== 'errored') return null;
-  const signalText = [
-    result.reason,
-    result.model_unavailable,
-    result.claude && result.claude.summary,
-    result.claude && result.claude.receipt_text,
-    result.claude && result.claude.stderr,
-    result.rate_limit_info && JSON.stringify(result.rate_limit_info),
-  ].filter(Boolean).join('\n').toLowerCase();
-  if (/usage[ _-]?limit|purchase more credits|insufficient credits|credit(?:s)?[ _-]?(?:out|limit)|rate[ _-]?limit/.test(signalText)) {
-    return 'credit_out';
-  }
-  if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
-  // Any other errored tick (claude-error, no-ready-engine's sibling failures,
-  // etc.) is still a real failure signal for the engine that ran it. Falling
-  // through to null here left the registry showing "ready" for an engine
-  // that had just hard-failed (e.g. a 401), so auto routing kept sending
-  // ticks back to it. Mark it "error" instead of silently doing nothing.
-  return 'error';
-}
-
 function recordMissionEngineTickOutcome(engineId, result, root = process.cwd()) {
   if (!engineId) return null;
   const status = result && result.status === 'ran' ? 'ready' : engineFailureHealthStatus(result);

package/commands/youtube.js

@@ -1,8 +1,12 @@
 const { apiRequestJson } = require('../utils/api');
 const { ensureValidCredentials } = require('../utils/auth');
 const { spawnSync } = require('child_process');
+const path = require('path');
 const https = require('https');
 
+const YTNOTES_USAGE = 'usage: ytnotes <youtube-url> [haiku|atris-fast|gemini|grok|codex|cursor]';
+const YTNOTES_HINT = 'zero credits, local captions + a fast engine';
+
 const DEFAULT_QUERY = [
   'Create a timestamped YouTube brief for Atris.',
   'Include: metadata, timestamped outline, core claims with confidence, memorable examples, actionable takeaways, Atris/product implications, and next actions.',
@@ -19,9 +23,11 @@ const ALLOWED_CAPTION_HOST_SUFFIXES = [
 
 function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('');
-  output(`Usage: ${commandName} process <youtube-url> [options]`);
+  output(`Usage: ${commandName} notes <youtube-url> [engine]`);
+  output(`       ${commandName} process <youtube-url> [options]`);
   output(`       ${commandName} <youtube-url> [options]`);
   output('');
+  output('notes = free local notes, process = 5 credits cloud knowledge');
   output('Process a YouTube video through Atris using timestamped transcript-first analysis.');
   output('Falls back to cloud video processing when local captions are unavailable.');
   output('');
@@ -37,6 +43,7 @@ function showYoutubeHelp(output = console.log, commandName = 'atris youtube') {
   output('  metadata -> timestamped outline -> claims -> examples -> takeaways -> Atris implications -> next actions');
   output('');
   output('Examples:');
+  output(`  ${commandName} notes https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} https://www.youtube.com/watch?v=VIDEO_ID`);
   output(`  ${commandName} process https://youtu.be/VIDEO_ID --query "Key takeaways"`);
   output('');
@@ -437,8 +444,31 @@ function formatYoutubeResult(data) {
   return lines.join('\n');
 }
 
+function runYoutubeNotes(args = [], deps = {}) {
+  const output = deps.output || ((line = '') => console.error(line));
+  const url = args[0];
+  const engine = args[1];
+  if (!url) {
+    output(YTNOTES_USAGE);
+    output(YTNOTES_HINT);
+    return 2;
+  }
+
+  const script = path.join(__dirname, '..', 'scripts', 'det', 'ytnotes');
+  const spawn = deps.spawnSync || spawnSync;
+  const childArgs = engine ? [url, engine] : [url];
+  const result = spawn(script, childArgs, { stdio: 'inherit' });
+  if (result.status == null) return 1;
+  return result.status;
+}
+
 async function youtubeCommand(argv = process.argv.slice(3), deps = {}) {
   const output = deps.output || ((line = '') => console.log(line));
+  if (argv[0] === 'notes') {
+    const code = runYoutubeNotes(argv.slice(1), deps);
+    if (!deps.output && !deps.spawnSync) process.exit(code);
+    return code;
+  }
   const options = parseYoutubeArgs(argv);
   if (options.help) {
     showYoutubeHelp(output, deps.commandName || 'atris youtube');

package/lib/engine-ask.js

@@ -9,7 +9,11 @@ const {
   DEFAULT_CLAUDE_RUNNER_MODEL,
   RUNNER_PROFILE_DEFS,
 } = require('./runner-command');
-const { canonicalEngineName } = require('./engine-registry');
+const {
+  canonicalEngineName,
+  engineFailureHealthStatus,
+  setEngineHealth,
+} = require('./engine-registry');
 const {
   appendEngineLiveLogChunk,
   createEngineLiveLog,
@@ -452,6 +456,15 @@ function answerStatus(answer) {
   return engineTerminalStatus(answer);
 }
 
+function recordEngineAskHealth(answers, root) {
+  for (const answer of answers) {
+    const status = answer.ok
+      ? 'ready'
+      : engineFailureHealthStatus({ ...answer, status: 'errored' });
+    if (status) setEngineHealth(answer.engine, status, root);
+  }
+}
+
 function engineAskReceipt(answers, { concurrency, timeoutMs, at = new Date().toISOString() }) {
   const receiptAnswers = answers.map((answer) => ({ ...answer, status: answerStatus(answer) }));
   const answered = receiptAnswers.filter((answer) => answer.status === 'answered').length;
@@ -582,6 +595,7 @@ async function runEngineAskCommand(args, root = process.cwd(), deps = {}) {
       signal: abort.signal,
       onOutputChunk: (chunk, stream) => appendLiveLog(liveLogPath, chunk, stream),
     });
+    recordEngineAskHealth(answers, root);
     const receipt = engineAskReceipt(answers, {
       concurrency: parsed.concurrency,
       timeoutMs: parsed.timeoutMs,

package/lib/engine-registry.js

@@ -16,6 +16,27 @@ const ENGINE_ROLES = Object.freeze(['navigator', 'executor', 'validator']);
 const ENGINE_DUTIES = Object.freeze(['leader', 'errands', 'learning']);
 const ENGINE_HEALTH_STATUSES = Object.freeze(['ready', 'not_installed', 'credit_out', 'error']);
 
+function engineFailureHealthStatus(result) {
+  if (!result || result.status !== 'errored') return null;
+  const signalText = [
+    result.reason,
+    result.model_unavailable,
+    result.report,
+    result.stdout,
+    result.stderr,
+    result.error,
+    result.claude && result.claude.summary,
+    result.claude && result.claude.receipt_text,
+    result.claude && result.claude.stderr,
+    result.rate_limit_info && JSON.stringify(result.rate_limit_info),
+  ].filter(Boolean).join('\n').toLowerCase();
+  if (/usage[ _-]?limit|purchase more credits|insufficient credits|credit(?:s)?[ _-]?(?:out|limit)|rate[ _-]?limit|not authenticated|please log in|login required|auth(?:entication)?[ _-]?expired|payment required|subscription/.test(signalText)) {
+    return 'credit_out';
+  }
+  if (/timeout|model-unavailable/.test(signalText)) return 'not_installed';
+  return 'error';
+}
+
 const ENGINE_SEED_META = Object.freeze({
   'atris-fast': Object.freeze({ tier: 'fast', roles: Object.freeze(['navigator']), models: Object.freeze(['atris fast']), duty: 'learning', fallback_order: 10 }),
   codex: Object.freeze({ tier: 'pro', roles: Object.freeze(['executor']), models: Object.freeze(['codex']), fallback_order: 10 }),
@@ -356,6 +377,7 @@ module.exports = {
   resolveEngineForRoleRanked,
   resolveEngineForRole,
   resolveEngineForRoleWithPreference,
+  engineFailureHealthStatus,
   setEngineOverrides,
   setEngineHealth,
 };

package/lib/fleet.js

@@ -23,6 +23,7 @@ const {
   worktreeBaseRef,
 } = require('./brief-ledger');
 const { RUNNER_PROFILE_DEFS, buildRunnerCommand } = require('./runner-command');
+const { engineFailureHealthStatus, setEngineHealth } = require('./engine-registry');
 const { resolveDefaultVerifier } = require('./default-verifier');
 const { rankEnginesDetailed } = require('./router-brain');
 const {
@@ -560,6 +561,18 @@ function detectDeadEngineDispatch(result) {
   return { reason: 'nonzero_exit', exitCode };
 }
 
+function recordDispatchEngineHealth(result, failure, root) {
+  if (!result || !result.engine) return null;
+  const status = failure
+    ? engineFailureHealthStatus({
+      ...result,
+      status: 'errored',
+      reason: [result.reason, failure.reason].filter(Boolean).join('\n'),
+    })
+    : 'ready';
+  return status ? setEngineHealth(result.engine, status, root) : null;
+}
+
 function normalizeInstalledEngines(engines) {
   return [...new Set((engines || [])
     .map((entry) => (typeof entry === 'string' ? entry : entry && entry.name))
@@ -672,6 +685,7 @@ async function dispatchEntryWithRestaff({
 
   const first = await runOnce(engine);
   const deadEngine = detectDeadEngineDispatch(first);
+  recordDispatchEngineHealth(first, deadEngine, root);
   if (!deadEngine) return first;
   stampDispatchBrief(root, first.brief_id, 'fail', `restaffed from ${engine}: ${deadEngine.reason}`);
 
@@ -687,6 +701,7 @@ async function dispatchEntryWithRestaff({
 
   restaffState.used = true;
   const fallbackResult = await runOnce(fallback);
+  recordDispatchEngineHealth(fallbackResult, detectDeadEngineDispatch(fallbackResult), root);
   return {
     ...fallbackResult,
     restaffed: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.47.0",
+  "version": "3.48.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -14,6 +14,7 @@
     "commands/",
     "decks/",
     "scripts/agent_worktree.py",
+    "scripts/det/",
     "utils/",
     "lib/",
     "templates/",

package/scripts/det/README.md

@@ -0,0 +1,162 @@
+# Deterministic task scripts
+
+Small, zero-dependency scripts for jobs LLMs get asked to do constantly but that
+are actually deterministic: extracting, converting, counting, reformatting text,
+and drafting commit/PR text from git. A cheap model (or a human, or a cron) runs
+the script instead of spending tokens and risking a wrong guess. The output is
+exact and reproducible, not inferred.
+
+## Pick a tool (one read)
+
+Find the row that matches the ask, run the command. All paths are under
+`node scripts/det/`. Add `--json` to any script for structured output.
+
+| If the ask is… | Run | Modes / notes |
+|----------------|-----|---------------|
+| pull links / emails / code / numbers out of text | `extract.js <mode> < in` | `urls` `emails` `code` `numbers` `ipv4` `hashtags` |
+| reformat / validate / flatten JSON, or JSON to CSV | `json.js <mode> < in` | `pretty` `min` `validate` `keys` `csv` |
+| dedupe / sort / count / slugify / trim lines | `text.js <mode> < in` | `dedupe` `sort` `rsort` `count` `slug` `trim` |
+| base64 / hex encode-decode, sha256 / sha1 / md5 hash | `hash.js <mode> < in` | `b64` `b64d` `sha256` `sha1` `md5` `hexenc` `hexdec` |
+| convert a timestamp, or get the weekday (all UTC) | `date.js <mode> < in` | `iso` `epoch` `epochms` `weekday` |
+| write a commit message | `git add -A && commit-msg.js` | reads the staged diff |
+| summarize what changed since a release | `changelog.js [ref]` | reads git log |
+| write a PR description for this branch | `pr-description.js [base]` | reads the branch diff |
+
+If no row matches, do the task normally. This library grows one verified script
+at a time; never add one without a self-test.
+
+## How to call
+
+The first five read stdin, write stdout, exit 0 on success and non-zero on bad
+input. The last three read git directly (their input is the repo, not stdin).
+
+You can call any script directly, or use the dispatcher as a discovery front door:
+
+```bash
+node scripts/det/det.js                 # print the catalog (all 8 tools)
+node scripts/det/det.js <script> <mode> < input   # route stdin through it
+```
+
+`det.js` lists every tool: the five stdin scripts it can route, plus the three
+git-facing scripts (which it points you to run directly, since their input is the
+repo). The stdin catalog is derived from the scripts' own exports, so it can never
+drift from what actually runs. Trust the output; do not "improve" it.
+
+## stdin scripts
+
+### extract.js
+
+```bash
+cat page.html   | node scripts/det/extract.js urls
+node scripts/det/extract.js emails < contacts.txt
+node scripts/det/extract.js code   < README.md       # fenced blocks, contents only
+node scripts/det/extract.js --json urls < page.html  # JSON array
+```
+
+Duplicates removed, first-seen order preserved. Unknown mode exits 2.
+
+### json.js
+
+```bash
+cat data.json     | node scripts/det/json.js pretty       # 2-space indent
+node scripts/det/json.js min      < data.json             # minified
+node scripts/det/json.js validate < data.json             # "valid" or errors (exit 2)
+node scripts/det/json.js keys     < data.json             # top-level keys
+node scripts/det/json.js csv      < array.json            # array of objects -> RFC-4180 CSV
+```
+
+`csv` handles the escaping LLMs get wrong: fields with commas or quotes are
+quoted, inner quotes doubled. Columns follow first-seen key order across rows.
+
+### text.js
+
+```bash
+cat list.txt | node scripts/det/text.js dedupe    # drop dup lines, keep first order
+node scripts/det/text.js sort  < list.txt         # byte-order sort (rsort = reverse)
+node scripts/det/text.js count < list.txt         # lines / words / chars (tab-separated)
+node scripts/det/text.js slug  < titles.txt       # each line -> url slug (accents folded)
+node scripts/det/text.js trim  < messy.txt        # strip trailing ws, drop blank lines
+```
+
+`count` is exact, no more eyeballed line/word totals. `slug` folds accents
+(Café to cafe) so slugs are stable across inputs.
+
+### hash.js
+
+```bash
+printf 'hi' | node scripts/det/hash.js b64        # base64 encode (b64d decodes)
+node scripts/det/hash.js sha256 < file.txt        # real hex sha256 (sha1, md5 too)
+node scripts/det/hash.js hexenc < file.txt        # raw <-> hex (hexdec reverses)
+```
+
+A single trailing newline is stripped before encoding/hashing, so `echo hi` and
+`printf 'hi'` give the same result. These are real crypto digests, not the
+plausible-looking fakes an LLM emits.
+
+### date.js
+
+```bash
+echo 1700000000 | node scripts/det/date.js iso       # epoch (s or ms) -> ISO UTC
+echo 2026-07-07 | node scripts/det/date.js epoch     # date -> epoch seconds (epochms for ms)
+echo 2026-07-07 | node scripts/det/date.js weekday   # -> Tuesday
+```
+
+Everything is UTC and machine-independent: epoch auto-detects seconds vs ms, and
+a bare date string with no timezone is pinned to UTC instead of guessing local.
+
+## git-facing scripts
+
+These replace LLM *generation*, not just data munging. They read git directly, so
+there is no stdin and they sit outside the dispatcher catalog.
+
+### commit-msg.js
+
+```bash
+git add -A && node scripts/det/commit-msg.js        # print the drafted message
+node scripts/det/commit-msg.js --json               # {type,scope,subject,body,...}
+```
+
+Type and scope come from the changed paths (`docs`/`test`/`chore`/`feat`/`fix`,
+scope = deepest common dir); the body is exact diff stats. No intent-guessing.
+Multi-file changes name the lead file (the added one, else the biggest churn), as
+`add changelog.js (+2 more)`, never the vague `update 3 files`.
+
+### changelog.js
+
+```bash
+node scripts/det/changelog.js                       # since the last tag -> markdown
+node scripts/det/changelog.js v3.34.0               # since a specific ref
+node scripts/det/changelog.js v3.34.0 HEAD          # explicit range
+node scripts/det/changelog.js --json                # {sections,counts,breaking,...}
+```
+
+Sections, order, and bullets come straight from the commit subjects grouped by
+Conventional-Commits type (`feat` to Features, `fix` to Fixes, ...); `type!:`
+commits surface under BREAKING CHANGES. Subjects that don't match the header
+grammar land in "Other" so nothing is dropped. No paraphrase, no invented or
+missing entries.
+
+### pr-description.js
+
+```bash
+node scripts/det/pr-description.js                  # diff origin/master...HEAD -> markdown
+node scripts/det/pr-description.js origin/main      # different base branch
+node scripts/det/pr-description.js origin/main HEAD # explicit base + head
+node scripts/det/pr-description.js --json           # {title,summary,testPlan,...}
+```
+
+Title comes from the commits (one commit -> its subject; many -> dominant type
+plus lead file); the summary is one bullet per changed area with counts and
+churn; the test-plan lists the touched test files plus one check per non-test
+area. Every line is backed by a real change in the diff, no invented rationale.
+
+## Verifying the library
+
+```bash
+node scripts/det/test.js   # runs every script against known input/output
+```
+
+Runs fast, no deps, CI-safe. A script is not "done" until it appears here with a
+passing test. This suite is also gated by the repo's `npm test` via
+`test/det.test.js`, which runs it as a subprocess, so the library cannot silently
+rot in CI.

package/scripts/det/ax-lane-eval.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+'use strict';
+
+// Grade the ax auto lane picker against the labeled gold set.
+// Usage: node scripts/det/ax-lane-eval.js [--json] [--min-accuracy <0..1>]
+// Cost-weighted error: routing up-lane work down (quality miss) counts 3x
+// routing down-lane work up (cost miss), because a wrong cheap answer is
+// worse than an overpriced right one.
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { pickLane } = require('../../lib/ax-auto-lane');
+
+const LANES = ['fast', 'pro', 'max', 'code-fast'];
+// Depth order for miss direction; code-fast sits beside pro in cost.
+const DEPTH = { fast: 0, 'code-fast': 1, pro: 1, max: 2 };
+const QUALITY_MISS_WEIGHT = 3;
+const COST_MISS_WEIGHT = 1;
+
+function loadGold() {
+  const dataIndex = process.argv.indexOf('--data');
+  const file = dataIndex >= 0
+    ? path.resolve(process.argv[dataIndex + 1])
+    : path.join(__dirname, 'data', 'ax-lane-gold.jsonl');
+  return fs.readFileSync(file, 'utf8')
+    .split(/\r?\n/)
+    .filter((line) => line.trim())
+    .map((line) => JSON.parse(line));
+}
+
+function evaluate() {
+  const gold = loadGold();
+  const confusion = {};
+  for (const a of LANES) {
+    confusion[a] = {};
+    for (const b of LANES) confusion[a][b] = 0;
+  }
+  const misses = [];
+  let correct = 0;
+  let weightedError = 0;
+  let worstWeight = 0;
+  for (const row of gold) {
+    const picked = pickLane(row.message).lane;
+    confusion[row.lane][picked] += 1;
+    if (picked === row.lane) {
+      correct += 1;
+      continue;
+    }
+    const qualityMiss = DEPTH[picked] < DEPTH[row.lane];
+    const weight = qualityMiss ? QUALITY_MISS_WEIGHT : COST_MISS_WEIGHT;
+    weightedError += weight;
+    worstWeight += QUALITY_MISS_WEIGHT;
+    misses.push({
+      message: row.message.slice(0, 70),
+      gold: row.lane,
+      picked,
+      kind: qualityMiss ? 'quality-miss' : 'cost-miss',
+      why: row.why,
+    });
+  }
+  const perLane = LANES.map((lane) => {
+    const truePos = confusion[lane][lane];
+    const goldCount = LANES.reduce((sum, other) => sum + confusion[lane][other], 0);
+    const pickedCount = LANES.reduce((sum, other) => sum + confusion[other][lane], 0);
+    return {
+      lane,
+      gold: goldCount,
+      recall: goldCount ? truePos / goldCount : null,
+      precision: pickedCount ? truePos / pickedCount : null,
+    };
+  });
+  const total = gold.length;
+  return {
+    total,
+    correct,
+    accuracy: correct / total,
+    quality_misses: misses.filter((m) => m.kind === 'quality-miss').length,
+    cost_misses: misses.filter((m) => m.kind === 'cost-miss').length,
+    weighted_error_rate: worstWeight ? weightedError / (total * QUALITY_MISS_WEIGHT) : 0,
+    per_lane: perLane,
+    confusion,
+    misses,
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const json = args.includes('--json');
+  const minIndex = args.indexOf('--min-accuracy');
+  const minAccuracy = minIndex >= 0 ? Number(args[minIndex + 1]) : null;
+  const report = evaluate();
+  if (json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    const pct = (value) => (value === null ? '  n/a' : `${(value * 100).toFixed(0)}%`.padStart(5));
+    console.log(`\nax auto lane eval: ${report.correct}/${report.total} correct (${pct(report.accuracy)})`);
+    console.log(`quality misses: ${report.quality_misses}  cost misses: ${report.cost_misses}  weighted error: ${(report.weighted_error_rate * 100).toFixed(1)}%\n`);
+    console.log('lane        gold  recall  precision');
+    for (const row of report.per_lane) {
+      console.log(`${row.lane.padEnd(11)} ${String(row.gold).padStart(4)}  ${pct(row.recall)}   ${pct(row.precision)}`);
+    }
+    if (report.misses.length) {
+      console.log('\nmisses:');
+      for (const miss of report.misses) {
+        console.log(`  [${miss.kind}] gold=${miss.gold} picked=${miss.picked}  "${miss.message}"`);
+      }
+    }
+    console.log('');
+  }
+  if (minAccuracy !== null && report.accuracy < minAccuracy) {
+    console.error(`accuracy ${(report.accuracy * 100).toFixed(1)}% is below the ${(minAccuracy * 100).toFixed(0)}% floor`);
+    process.exit(1);
+  }
+}
+
+main();