atris 3.61.0 → 3.62.0

package/lib/self-drive.js

@@ -141,6 +141,8 @@ function defaultDependencies() {
     taskDb,
     resolveEngineForRole: require('./engine-registry').resolveEngineForRole,
     dispatchToEngine: require('./fleet').dispatchToEngine,
+    recordDispatchOutcome: require('./fleet').recordDispatchOutcome,
+    clock: Date.now,
     createAgentWorktree: require('../commands/worktree').createAgentWorktree,
   };
 }
@@ -272,7 +274,13 @@ function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent
       agent: engine.id,
       task: `mission-blocker-${String(ref).toLowerCase()}`,
     });
-    deps.dispatchToEngine({
+    const pin = {
+      model: engine.roster_model || '',
+      effort: engine.roster_effort || '',
+      maxSeconds: Number(engine.roster_max_seconds) || 0,
+    };
+    const startedMs = deps.clock();
+    const dispatched = deps.dispatchToEngine({
       task,
       engine: engine.id,
       worktreePath: worktree.path,
@@ -281,14 +289,30 @@ function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent
       ...(engine.roster_effort ? { effort: engine.roster_effort } : {}),
       ...(engine.roster_max_seconds ? { maxSeconds: engine.roster_max_seconds } : {}),
     });
+    // How the engine did goes through the same health and run-record calls
+    // as every other dispatch, so a stalled blocker build benches it.
+    const run = dispatched && typeof dispatched === 'object' && typeof dispatched.then !== 'function'
+      ? deps.recordDispatchOutcome(scopedRoot, {
+        engine: engine.id,
+        pin,
+        startedMs,
+        endedMs: deps.clock(),
+        result: dispatched,
+        job: 'build',
+        task: ref,
+        source: 'mission blocker',
+        member: mission.owner || '',
+      })
+      : null;
     projectTasks(deps.taskDb, db, scopedRoot);
     appendEvent?.('mission_blocker_dispatched', {
       task_id: ref,
       engine: engine.id,
       blocker_class: blockerClass,
       worktree_path: worktree.path,
+      ...(run ? { outcome: run.outcome } : {}),
     });
-    return { taskId: ref, dispatched: true, engine: engine.id, reason: 'dispatched' };
+    return { taskId: ref, dispatched: true, engine: engine.id, reason: 'dispatched', ...(run ? { outcome: run.outcome, ...(run.detail ? { detail: run.detail } : {}) } : {}) };
   } catch (error) {
     return { taskId: ref, dispatched: false, engine: engine.id, reason: error.message || String(error) };
   }

package/lib/state-detection.js

@@ -131,7 +131,7 @@ function getTasksFromDbBucket(atrisDir, bucketName) {
     const taskDb = require('./task-db');
     if (!fs.existsSync(taskDb.getDbPath())) return null;
     const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
-    const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+    const rows = taskDb.listTasksCached(taskDb.open(), { workspaceRoot, limit: 500 });
     if (!rows.length) return null;
     return rows
       .filter(row => statuses.has(String(row.status || '').toLowerCase()))
@@ -151,7 +151,7 @@ function getTaskCounts(atrisDir) {
     const taskDb = require('./task-db');
     if (fs.existsSync(taskDb.getDbPath())) {
       const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
-      const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+      const rows = taskDb.listTasksCached(taskDb.open(), { workspaceRoot, limit: 500 });
       if (rows.length) {
         const counts = { backlog: 0, active: 0, review: 0, reviewCertified: 0, source: 'db' };
         for (const row of rows) {
@@ -190,7 +190,7 @@ function getTaskGlance(atrisDir, sampleSize = 3) {
     const taskDb = require('./task-db');
     if (fs.existsSync(taskDb.getDbPath())) {
       const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
-      const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+      const rows = taskDb.listTasksCached(taskDb.open(), { workspaceRoot, limit: 500 });
       if (rows.length) {
         const glance = {
           backlog: 0, active: 0, review: 0, reviewCertified: 0,

package/lib/task-db.js

@@ -333,10 +333,14 @@ function taskDisplayRef(row, index) {
   return `${workspaceRefPrefix(row && row.workspace_root)}-${Number(index) + 1}`;
 }
 
-function shortestUniqueTaskRef(id, ids, minLength = 8) {
+// normalizedIds: the ids already passed through normalizeTaskRef, so a caller
+// resolving every row of a list normalizes the list once, not once per row.
+function shortestUniqueTaskRef(id, ids, minLength = 8, normalizedIds = null) {
   const normalized = normalizeTaskRef(id);
   if (!normalized) return '';
-  const all = (Array.isArray(ids) ? ids : []).map(normalizeTaskRef).filter(Boolean);
+  const all = Array.isArray(normalizedIds)
+    ? normalizedIds
+    : (Array.isArray(ids) ? ids : []).map(normalizeTaskRef).filter(Boolean);
   for (let length = Math.min(minLength, normalized.length); length <= normalized.length; length += 1) {
     const prefix = normalized.slice(0, length);
     const matches = all.filter(candidate => candidate.startsWith(prefix));
@@ -364,10 +368,11 @@ function withTaskDisplayRefs(rows, refRows = rows) {
     const sorted = [...group]
       .sort((a, b) => (Number(a.created_at || 0) - Number(b.created_at || 0)) || String(a.id || '').localeCompare(String(b.id || '')))
     const ids = sorted.map(row => row && row.id);
+    const normalizedIds = ids.map(normalizeTaskRef).filter(Boolean);
     sorted.forEach((row, index) => {
       refs.set(row.id, {
         display_id: row.display_id || taskDisplayRef(row, index),
-        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8),
+        legacy_ref: row.legacy_ref || shortestUniqueTaskRef(row.id, ids, 8, normalizedIds),
       });
     });
   }
@@ -470,6 +475,35 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
   }));
 }
 
+// Boot reads the same task list from several places (the TODO buckets and
+// the status glance). Share one read per connection while nothing changed:
+// PRAGMA data_version moves when another connection commits, and
+// total_changes() moves when this connection writes. Callers must treat the
+// rows as read-only.
+const listTasksMemo = new WeakMap();
+
+function listTasksCached(db, opts = {}) {
+  let stamp;
+  try {
+    const version = db.prepare('PRAGMA data_version').get();
+    const changes = db.prepare('SELECT total_changes() AS n').get();
+    stamp = `${Object.values(version || {})[0]}:${changes && changes.n}`;
+  } catch {
+    return listTasks(db, opts);
+  }
+  const key = JSON.stringify([opts.workspaceRoot || '', opts.status || '', opts.claimedBy || '', opts.limit || 0]);
+  let byKey = listTasksMemo.get(db);
+  if (!byKey) {
+    byKey = new Map();
+    listTasksMemo.set(db, byKey);
+  }
+  const hit = byKey.get(key);
+  if (hit && hit.stamp === stamp) return hit.rows;
+  const rows = listTasks(db, opts);
+  byKey.set(key, { stamp, rows });
+  return rows;
+}
+
 function getTask(db, id) {
   if (!id) throw new Error('id required');
   const row = db.prepare(`
@@ -2243,6 +2277,7 @@ module.exports = {
   addTask,
   getTask,
   listTasks,
+  listTasksCached,
   claimTask,
   releaseTask,
   reopenTask,

package/lib/team-lineup.js

@@ -6,6 +6,7 @@
 
 const { engineRunsView, modelLabel } = require('./roster-models');
 const { rosterToolLabel } = require('./engine-registry');
+const { suggestionCount } = require('./roster-suggest');
 
 const BUILT_IN_JOBS = Object.freeze(['build', 'review', 'search']);
 const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
@@ -51,6 +52,8 @@ function readLineupSafe(root = process.cwd(), now = new Date()) {
 
 // One boot line: the tool and model that runs each built-in job right now,
 // custom jobs only when all of them still fit. '' when nothing resolves.
+// When the run record suggests a new order for any job, a short marker
+// points at the roster view; only the end of the record is read.
 function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs = null } = {}) {
   let rows = jobs;
   if (!rows) {
@@ -65,9 +68,11 @@ function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs
   const builtIn = ordered.filter((row) => BUILT_IN_JOBS.includes(row.job) && !row.key).map(part).filter(Boolean);
   const custom = ordered.filter((row) => !BUILT_IN_JOBS.includes(row.job) || row.key).map(part).filter(Boolean);
   if (!builtIn.length && !custom.length) return '';
+  const count = suggestionCount(ordered, root, { now });
+  const marker = count ? ` · ${count} suggestion${count === 1 ? '' : 's'} (atris engine roster)` : '';
   const all = [...builtIn, ...custom].join(' · ');
-  if (all.length <= width || !builtIn.length) return all;
-  return builtIn.join(' · ');
+  if (all.length + marker.length <= width || !builtIn.length) return `${all}${marker}`;
+  return `${builtIn.join(' · ')}${marker}`;
 }
 
 function runsText(view) {

package/lib/todo.js

@@ -41,7 +41,7 @@ function dbToShimRow(row) {
 function dbBuckets(workspaceRoot) {
   const taskDb = require('./task-db');
   const db = taskDb.open();
-  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot, limit: 500 }));
+  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasksCached(db, { workspaceRoot, limit: 500 }));
   // Need raw source_key for merge dedup, plus the shim shape for callers.
   const backlog = [];
   const inProgress = [];

package/lib/wish-audit.js

@@ -424,7 +424,7 @@ function policyValidator(root, excludeId = '') {
       .filter((engine) => engine.id !== String(excludeId || ''))
       .sort((a, b) => Number(a.fallback_order) - Number(b.fallback_order)
         || String(a.id).localeCompare(String(b.id)));
-    return ranked.find((engine) => engine.health && engine.health.status === 'ready') || ranked[0] || null;
+    return ranked.find((engine) => engineRegistry.engineReadyAt(engine)) || ranked[0] || null;
   } catch {
     return null;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.61.0",
+  "version": "3.62.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {

package/scripts/det/cpu-hotspots.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+// det/cpu-hotspots.js - where does an atris command spend its time?
+// Runs one command under `node --cpu-prof` in a temp profile dir, then prints
+// the total profiled ms, the top self-time hotspots, and the top call chains
+// that end in spawnSync (application frames only, so node internals and
+// node_modules drop out). Optional plain wall-clock runs give a median.
+//
+// Usage:
+//   node scripts/det/cpu-hotspots.js [options] -- <script.js> [args...]
+//   node scripts/det/cpu-hotspots.js --cwd ../repo -- bin/atris.js atris.md
+//   node scripts/det/cpu-hotspots.js --wall 5 --top 15 -- bin/atris.js team
+//
+// Options:
+//   --cwd <dir>     working directory for the profiled command (default: here)
+//   --top <n>       rows per table (default 10)
+//   --wall <n>      also time n unprofiled runs and print the median wall ms
+//   --app <dir>     frames under this dir count as application frames
+//                   (default: the repo that holds this script)
+//   --keep          keep the temp profile dir and print its path
+//   --json          structured output
+//
+// The command's own stdout is discarded; its exit code is reported.
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const DEFAULT_APP_ROOT = path.resolve(__dirname, '..', '..');
+
+function parseArgs(argv) {
+  const opts = { cwd: process.cwd(), top: 10, wall: 0, app: DEFAULT_APP_ROOT, keep: false, json: false, command: [] };
+  const sep = argv.indexOf('--');
+  const head = sep === -1 ? argv : argv.slice(0, sep);
+  opts.command = sep === -1 ? [] : argv.slice(sep + 1);
+  for (let i = 0; i < head.length; i += 1) {
+    const arg = head[i];
+    if (arg === '--cwd') opts.cwd = path.resolve(head[++i] || '.');
+    else if (arg === '--top') opts.top = Math.max(1, Number(head[++i]) || 10);
+    else if (arg === '--wall') opts.wall = Math.max(0, Number(head[++i]) || 0);
+    else if (arg === '--app') opts.app = path.resolve(head[++i] || '.');
+    else if (arg === '--keep') opts.keep = true;
+    else if (arg === '--json') opts.json = true;
+    else if (arg === '-h' || arg === '--help') opts.help = true;
+    else opts.command.push(arg);
+  }
+  return opts;
+}
+
+function frameFile(url) {
+  return String(url || '').replace(/^file:\/\//, '');
+}
+
+function isAppFrame(frame, appRoot) {
+  const file = frameFile(frame.url);
+  if (!file || !file.startsWith(appRoot)) return false;
+  return !file.includes(`${path.sep}node_modules${path.sep}`);
+}
+
+function frameLabel(frame, appRoot) {
+  const file = frameFile(frame.url);
+  const rel = appRoot && file.startsWith(appRoot) ? path.relative(appRoot, file) : (file || '(native)');
+  const name = frame.functionName || '(anonymous)';
+  return `${name} ${rel}:${Number(frame.lineNumber) + 1}`;
+}
+
+// Pure core: a parsed .cpuprofile in, tables out. Unit-testable.
+function analyzeProfile(profile, { appRoot = DEFAULT_APP_ROOT, top = 10 } = {}) {
+  const nodes = new Map();
+  const parent = new Map();
+  for (const node of profile.nodes || []) {
+    nodes.set(node.id, node);
+    for (const child of node.children || []) parent.set(child, node.id);
+  }
+  const selfUs = new Map();
+  const samples = profile.samples || [];
+  const deltas = profile.timeDeltas || [];
+  for (let i = 0; i < samples.length; i += 1) {
+    const dt = Math.max(0, Number(deltas[i]) || 0);
+    selfUs.set(samples[i], (selfUs.get(samples[i]) || 0) + dt);
+  }
+  const totalUs = [...selfUs.values()].reduce((a, b) => a + b, 0)
+    || Math.max(0, Number(profile.endTime) - Number(profile.startTime)) || 0;
+
+  const byFrame = new Map();
+  for (const [id, us] of selfUs) {
+    const node = nodes.get(id);
+    if (!node) continue;
+    const label = frameLabel(node.callFrame || {}, appRoot);
+    byFrame.set(label, (byFrame.get(label) || 0) + us);
+  }
+  const hotspots = [...byFrame.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, top)
+    .map(([frame, us]) => ({ frame, ms: Math.round(us / 1000) }));
+
+  // Time under each spawnSync node = self time of every descendant sample.
+  const subtreeUs = new Map();
+  for (const [id, us] of selfUs) {
+    let cur = id;
+    const seen = new Set();
+    while (cur !== undefined && !seen.has(cur)) {
+      seen.add(cur);
+      subtreeUs.set(cur, (subtreeUs.get(cur) || 0) + us);
+      cur = parent.get(cur);
+    }
+  }
+  const chains = new Map();
+  for (const node of nodes.values()) {
+    const fn = node.callFrame && node.callFrame.functionName;
+    if (fn !== 'spawnSync') continue;
+    // Only the outermost spawnSync on a path counts (child_process wraps an
+    // internal spawnSync of the same name).
+    let up = parent.get(node.id);
+    let nested = false;
+    while (up !== undefined) {
+      const upNode = nodes.get(up);
+      if (upNode && upNode.callFrame && upNode.callFrame.functionName === 'spawnSync') { nested = true; break; }
+      up = parent.get(up);
+    }
+    if (nested) continue;
+    const us = subtreeUs.get(node.id) || 0;
+    if (!us) continue;
+    const frames = [];
+    let cur = parent.get(node.id);
+    while (cur !== undefined) {
+      const n = nodes.get(cur);
+      if (n && n.callFrame && isAppFrame(n.callFrame, appRoot)) frames.push(frameLabel(n.callFrame, appRoot));
+      cur = parent.get(cur);
+    }
+    const key = frames.slice(0, 6).join(' < ') || '(no app frames)';
+    chains.set(key, (chains.get(key) || 0) + us);
+  }
+  const spawnTotalUs = [...chains.values()].reduce((a, b) => a + b, 0);
+  const spawnChains = [...chains.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, top)
+    .map(([chain, us]) => ({ chain, ms: Math.round(us / 1000) }));
+  return { total_ms: Math.round(totalUs / 1000), spawn_ms: Math.round(spawnTotalUs / 1000), hotspots, spawn_chains: spawnChains };
+}
+
+function median(values) {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[mid] : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+}
+
+function timeRun(command, cwd, extraArgs = []) {
+  const start = process.hrtime.bigint();
+  const result = spawnSync(process.execPath, [...extraArgs, ...command], { cwd, stdio: ['ignore', 'ignore', 'pipe'], encoding: 'utf8' });
+  const ms = Number(process.hrtime.bigint() - start) / 1e6;
+  return { ms: Math.round(ms), status: result.status, stderr: result.stderr || '' };
+}
+
+function resolveCommand(command) {
+  if (!command.length) return command;
+  const [script, ...rest] = command;
+  const abs = path.isAbsolute(script) ? script : path.resolve(process.cwd(), script);
+  return [fs.existsSync(abs) ? abs : script, ...rest];
+}
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.help || !opts.command.length) {
+    process.stderr.write('usage: node scripts/det/cpu-hotspots.js [--cwd dir] [--top n] [--wall n] [--json] -- <script.js> [args...]\n');
+    return opts.help ? 0 : 2;
+  }
+  const command = resolveCommand(opts.command);
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-cpu-prof-'));
+  const profiled = timeRun(command, opts.cwd, ['--cpu-prof', `--cpu-prof-dir=${dir}`]);
+  const files = fs.readdirSync(dir).filter((f) => f.endsWith('.cpuprofile'))
+    .map((f) => path.join(dir, f))
+    .sort((a, b) => fs.statSync(b).size - fs.statSync(a).size);
+  if (!files.length) {
+    process.stderr.write(`no profile written (exit ${profiled.status})\n${profiled.stderr.slice(0, 800)}`);
+    return 1;
+  }
+  const report = analyzeProfile(JSON.parse(fs.readFileSync(files[0], 'utf8')), { appRoot: opts.app, top: opts.top });
+  report.command = command.join(' ');
+  report.exit_code = profiled.status;
+  report.profiled_wall_ms = profiled.ms;
+  if (opts.wall) {
+    const walls = [];
+    for (let i = 0; i < opts.wall; i += 1) walls.push(timeRun(command, opts.cwd).ms);
+    report.wall_runs_ms = walls;
+    report.wall_median_ms = median(walls);
+  }
+  if (opts.keep) report.profile_dir = dir;
+  else fs.rmSync(dir, { recursive: true, force: true });
+
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return 0;
+  }
+  const out = [];
+  out.push(`command: ${report.command} (exit ${report.exit_code})`);
+  out.push(`profiled: ${report.total_ms} ms cpu profile, ${report.profiled_wall_ms} ms wall, ${report.spawn_ms} ms in spawnSync`);
+  if (opts.wall) out.push(`wall median of ${opts.wall}: ${report.wall_median_ms} ms (${report.wall_runs_ms.join(', ')})`);
+  out.push('');
+  out.push('top self time:');
+  for (const row of report.hotspots) out.push(`  ${String(row.ms).padStart(6)} ms  ${row.frame}`);
+  out.push('');
+  out.push('top spawnSync chains:');
+  if (!report.spawn_chains.length) out.push('  (none)');
+  for (const row of report.spawn_chains) out.push(`  ${String(row.ms).padStart(6)} ms  ${row.chain}`);
+  if (report.profile_dir) out.push('', `profile dir: ${report.profile_dir}`);
+  process.stdout.write(`${out.join('\n')}\n`);
+  return 0;
+}
+
+if (require.main === module) process.exitCode = main();
+
+module.exports = { analyzeProfile, median, parseArgs };

package/scripts/det/ytnotes

@@ -1,11 +1,15 @@
 #!/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: Gemini Flash through agy, Haiku if that fails),
+# 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,16 +17,22 @@ 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
@@ -30,13 +40,13 @@ cd "$WORK"
 # 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.
 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 +124,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 +132,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 +145,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 +216,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 +252,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
 
@@ -282,26 +350,44 @@ 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 writer that answers: Gemini, then Haiku. Buffered so a failed or
+# empty Gemini answer never reaches the notes file.
+run_auto() {
+  local out=""
+  if out=$(run_gemini 2>"$WORK/yt_${ID}.engine.err") && printf '%s' "$out" | grep -q '[[:alnum:]]'; then
+    printf '%s\n' "$out"
+    return 0
+  fi
+  echo "Gemini did not answer; writing the notes with Haiku instead." >&2
+  run_haiku
+}
+
 {
   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 ;;
+    *) 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"