atris 3.74.24 → 3.74.26

package/commands/worktree.js

@@ -1201,7 +1201,6 @@ const PROTECTED_BRANCHES = new Set(['main', 'master']);
 // (zero commits yet), so without a grace window the janitor reaps it while
 // the engine that requested it is still booting inside.
 const WORKTREE_REAP_GRACE_MS = 60 * 60 * 1000;
-const COMPLETED_UNMERGED_REAP_MS = WORKTREE_REAP_GRACE_MS;
 const GENERATED_WORKTREE_CACHE_DIRS = [
   '.derivedData',
   '.next',
@@ -1218,15 +1217,6 @@ function worktreeWithinReapGrace(worktreePath, now = Date.now()) {
   }
 }
 
-function completedAgentOutputAgeMs(worktreePath, now = Date.now()) {
-  try {
-    const output = path.join(worktreePath, '.codex-last-message.txt');
-    return now - fs.statSync(output).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-
 function canonicalPath(value) {
   try {
     return fs.realpathSync(value);
@@ -1237,17 +1227,20 @@ function canonicalPath(value) {
 
 // null means the scan failed: we cannot tell who is inside, so callers keep
 // every folder. An empty list would read as "nobody is here" and delete.
-function listActiveProcessCwds() {
-  const result = spawnSync('lsof', ['-n', '-a', '-d', 'cwd', '-F', 'n'], {
+function listActiveProcessFiles() {
+  const result = spawnSync('lsof', ['-n', '-F', 'n'], {
     encoding: 'utf8',
     maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+    timeout: 20000,
+    killSignal: 'SIGKILL',
   });
-  if (result.error || result.status !== 0) return null;
-  return String(result.stdout || '')
+  if (result.error || result.status !== 0 || String(result.stderr || '').trim()) return null;
+  const paths = String(result.stdout || '')
     .split(/\r?\n/)
-    .filter((line) => line.startsWith('n'))
+    .filter((line) => line.startsWith('n/'))
     .map((line) => canonicalPath(line.slice(1)))
     .filter(Boolean);
+  return paths.length ? paths : null;
 }
 
 // Absolute paths named on each program's command line, including flag values
@@ -1274,17 +1267,20 @@ function listActiveProcessArgPaths() {
   const result = spawnSync('ps', ['-axww', '-o', 'args='], {
     encoding: 'utf8',
     maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+    timeout: 5000,
+    killSignal: 'SIGKILL',
   });
-  if (result.error || result.status !== 0) return [];
+  if (result.error || result.status !== 0) return null;
   return parseProcessArgPaths(result.stdout);
 }
 
-// Everything a running program is anchored to: its current folder plus any
-// script path on its command line.
+// Open files and working folders, plus script paths on command lines.
 function listActiveProcessPaths() {
-  const cwds = listActiveProcessCwds();
-  if (!Array.isArray(cwds)) return cwds;
-  return cwds.concat(listActiveProcessArgPaths());
+  const files = listActiveProcessFiles();
+  if (!Array.isArray(files)) return null;
+  const args = listActiveProcessArgPaths();
+  if (!Array.isArray(args)) return null;
+  return files.concat(args);
 }
 
 function worktreeHasActiveProcess(worktreePath, activeCwds) {
@@ -1311,7 +1307,44 @@ function recordWorktreeRemoval(root, { path: removedPath, branch = '', by, reaso
   } catch {}
 }
 
-function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
+// Only webpack's disposable pack files have a sufficiently narrow contract
+// for unattended cleanup. Unknown files or links turn the folder into review.
+function webpackCacheSnapshot(worktreePath) {
+  try {
+    const root = fs.realpathSync(worktreePath);
+    let current = root;
+    for (const part of ['.next', 'cache', 'webpack']) {
+      current = path.join(current, part);
+      const stat = fs.lstatSync(current);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) return null;
+    }
+    if (fs.realpathSync(current) !== current) return null;
+    const entries = [];
+    function walk(dir) {
+      for (const name of fs.readdirSync(dir).sort()) {
+        const file = path.join(dir, name);
+        const stat = fs.lstatSync(file);
+        if (stat.isSymbolicLink()) return false;
+        if (stat.isDirectory()) {
+          entries.push([file, 'd', stat.ino, stat.mtimeMs]);
+          if (!walk(file)) return false;
+        } else if (stat.isFile() && /^(?:index|\d+)\.pack(?:\.gz|\.old)?$/.test(name)) {
+          entries.push([file, 'f', stat.ino, stat.size, stat.mtimeMs]);
+        } else return false;
+      }
+      return true;
+    }
+    if (!walk(current)) return null;
+    const size = spawnSync('du', ['-sk', current], { encoding: 'utf8', timeout: 5000, killSignal: 'SIGKILL' });
+    const match = size.status === 0 && String(size.stdout || '').match(/^(\d+)\s/);
+    if (!match) return null;
+    return { path: current, kib: Number(match[1]), fingerprint: JSON.stringify(entries) };
+  } catch {
+    return null;
+  }
+}
+
+function pruneGeneratedWorktreeCaches(worktreePath, { apply = false, budget } = {}) {
   const candidates = [];
   const pruned = [];
   for (const relative of GENERATED_WORKTREE_CACHE_DIRS) {
@@ -1319,34 +1352,70 @@ function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
     if (!fs.existsSync(target)) continue;
     const ignored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
     if (ignored.status !== 0) continue;
-    const item = { worktree: worktreePath, path: target, relative };
+    const item = { worktree: worktreePath, path: target, relative, reason: 'manual_review_required' };
     candidates.push(item);
-    if (!apply) continue;
-    try {
-      fs.rmSync(target, { recursive: true, force: true });
-      pruned.push(item);
-    } catch (error) {
-      item.error = String((error && error.message) || error);
+  }
+  const relative = '.next/cache/webpack';
+  const ignored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
+  const snapshot = ignored.status === 0 ? webpackCacheSnapshot(worktreePath) : null;
+  if (snapshot) {
+    const item = { worktree: worktreePath, path: snapshot.path, relative, kib: snapshot.kib, reason: 'generated_webpack_cache' };
+    candidates.push(item);
+    if (apply && budget && budget.count < 20 && budget.kib + snapshot.kib <= 10 * 1024 * 1024) {
+      const active = listActiveProcessPaths();
+      const fresh = webpackCacheSnapshot(worktreePath);
+      const stillIgnored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
+      if (Array.isArray(active) && !worktreeHasActiveProcess(worktreePath, active)
+          && stillIgnored.status === 0 && fresh && fresh.path === snapshot.path
+          && fresh.kib === snapshot.kib && fresh.fingerprint === snapshot.fingerprint) {
+        try {
+          fs.rmSync(snapshot.path, { recursive: true });
+          budget.count += 1;
+          budget.kib += snapshot.kib;
+          pruned.push(item);
+        } catch (error) {
+          item.error = String((error && error.message) || error);
+        }
+      }
     }
   }
   return { candidates, pruned };
 }
 
+function originBaseIsCurrent(root, base) {
+  const prefix = base.startsWith('origin/') ? 'origin/'
+    : base.startsWith('refs/remotes/origin/') ? 'refs/remotes/origin/' : '';
+  if (!prefix) {
+    if (base === 'HEAD') {
+      const branch = runGit(['symbolic-ref', '--short', 'HEAD'], { cwd: root, check: false });
+      return branch.status === 0 && PROTECTED_BRANCHES.has(branch.stdout.trim());
+    }
+    return PROTECTED_BRANCHES.has(base.replace(/^refs\/heads\//, ''));
+  }
+  const branch = base.slice(prefix.length);
+  const local = runGit(['rev-parse', '--verify', base], { cwd: root, check: false });
+  const remote = runGit(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`], { cwd: root, check: false, timeout: 5000 });
+  const match = String(remote.stdout || '').match(/^([a-f0-9]{40,64})\s+(refs\/heads\/[^\r\n]+)$/m);
+  return local.status === 0 && remote.status === 0 && Boolean(match)
+    && match[2] === `refs/heads/${branch}` && local.stdout.trim() === match[1];
+}
+
 function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false, activeCwds: activeCwdsOverride, by = 'atris worktree cleanup' } = {}) {
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
   const current = path.resolve(root);
   const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessPaths();
   const base = normalizeTargetRef(root, baseOverride || defaultShipTarget(root));
-  refreshRemoteRef(root, base);
+  const refreshError = refreshRemoteRef(root, base);
   const candidates = [];
   const kept = [];
   const removed = [];
   const cacheCandidates = [];
   const cachePruned = [];
+  const cacheBudget = { count: 0, kib: 0 };
   const pruneCachesForKept = (wtPath) => {
     if (worktreeWithinReapGrace(wtPath)) return;
-    const caches = pruneGeneratedWorktreeCaches(wtPath, { apply });
+    const caches = pruneGeneratedWorktreeCaches(wtPath, { apply, budget: cacheBudget });
     cacheCandidates.push(...caches.candidates);
     cachePruned.push(...caches.pruned);
   };
@@ -1374,9 +1443,8 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       kept.push({ ...item, reason: activeCwds ? 'active_process' : 'process_scan_failed' });
       continue;
     }
-    const rawCounts = statusCounts(wt.path);
-    const counts = statusCounts(wt.path, { ignoreAny: isConductorArtifact });
-    if (!rawCounts || !counts) {
+    const counts = statusCounts(wt.path);
+    if (!counts) {
       kept.push({ ...item, reason: 'missing_or_unreadable' });
       continue;
     }
@@ -1385,58 +1453,78 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       kept.push({ ...item, reason: 'dirty', staged: counts.staged, unstaged: counts.unstaged, untracked: counts.untracked });
       continue;
     }
+    // Git removes ignored files along with a worktree. They may include local
+    // state, credentials, or user data, so a clean status is not enough proof.
+    const ignored = runGit(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], { cwd: wt.path, check: false });
+    if (ignored.status !== 0 || ignored.error) {
+      kept.push({ ...item, reason: 'ignored_scan_failed' });
+      continue;
+    }
+    if (ignored.stdout) {
+      pruneCachesForKept(wtPath);
+      kept.push({ ...item, reason: 'ignored_data' });
+      continue;
+    }
     if (!wt.head) {
       pruneCachesForKept(wtPath);
       kept.push({ ...item, reason: 'missing_head' });
       continue;
     }
-    const artifactOnlyDirty = Boolean(
-      (rawCounts.staged || rawCounts.unstaged || rawCounts.untracked)
-      && !(counts.staged || counts.unstaged || counts.untracked)
-    );
+    if (refreshError) {
+      kept.push({ ...item, reason: 'base_refresh_failed' });
+      continue;
+    }
     const merged = runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status === 0;
     if (!merged) {
-      const completedAgeMs = completedAgentOutputAgeMs(wtPath);
-      if (completedAgeMs === null || completedAgeMs < COMPLETED_UNMERGED_REAP_MS) {
-        pruneCachesForKept(wtPath);
-        kept.push({
-          ...item,
-          reason: completedAgeMs === null ? 'unmerged' : 'completed_unmerged_retention',
-          ...(completedAgeMs === null ? {} : { retention_hours: 1 }),
-        });
-        continue;
-      }
-      const candidate = {
-        ...item,
-        reason: 'completed_unmerged_checkout_expired',
-        branch_preserved: true,
-        artifact_only_dirty: artifactOnlyDirty,
-      };
-      candidates.push(candidate);
-      if (!apply) continue;
-      const removeArgs = ['worktree', 'remove'];
-      if (artifactOnlyDirty) removeArgs.push('--force');
-      removeArgs.push(wt.path);
-      const removedResult = runGit(removeArgs, { cwd: root, check: false });
-      if (removedResult.status === 0) {
-        removed.push(candidate);
-        recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason });
-      } else {
-        kept.push({ ...item, reason: 'remove_failed', error: (removedResult.stderr || removedResult.stdout || '').trim() });
-      }
+      pruneCachesForKept(wtPath);
+      kept.push({ ...item, reason: wt.branch === 'detached' ? 'detached_unmerged' : 'unmerged' });
       continue;
     }
     if (worktreeWithinReapGrace(wtPath)) {
       kept.push({ ...item, reason: 'fresh_worktree_grace' });
       continue;
     }
-    const candidate = { ...item, reason: 'merged_into_base', artifact_only_dirty: artifactOnlyDirty };
+    if (!originBaseIsCurrent(root, base)) {
+      kept.push({ ...item, reason: 'base_unverified' });
+      continue;
+    }
+    let real;
+    try { real = fs.realpathSync(wtPath); } catch { real = ''; }
+    if (!real || real !== wtPath) {
+      kept.push({ ...item, reason: 'path_not_canonical' });
+      continue;
+    }
+    const measured = spawnSync('du', ['-sk', wtPath], { encoding: 'utf8', timeout: 30000, killSignal: 'SIGKILL' });
+    const sizeMatch = measured.status === 0 && !String(measured.stderr || '').trim() && String(measured.stdout || '').match(/^(\d+)\s/);
+    const kib = sizeMatch ? Number(sizeMatch[1]) : 0;
+    if (!kib || cacheBudget.count >= 20 || cacheBudget.kib + kib > 10 * 1024 * 1024) {
+      kept.push({ ...item, reason: 'size_unknown_or_cleanup_limit' });
+      continue;
+    }
+    const candidate = { ...item, reason: 'merged_into_base', size_kib: kib };
     candidates.push(candidate);
+    cacheBudget.count += 1;
+    cacheBudget.kib += kib;
     if (!apply) continue;
-    const removeArgs = ['worktree', 'remove'];
-    if (artifactOnlyDirty) removeArgs.push('--force');
-    removeArgs.push(wt.path);
-    const removedResult = runGit(removeArgs, { cwd: root, check: false });
+    const freshActive = Array.isArray(activeCwdsOverride) ? activeCwds : listActiveProcessPaths();
+    const freshCounts = statusCounts(wt.path);
+    const freshIgnored = runGit(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], { cwd: wt.path, check: false });
+    const freshSize = spawnSync('du', ['-sk', wtPath], { encoding: 'utf8', timeout: 30000, killSignal: 'SIGKILL' });
+    const freshMatch = freshSize.status === 0 && !String(freshSize.stderr || '').trim() && String(freshSize.stdout || '').match(/^(\d+)\s/);
+    const gitdir = runGit(['rev-parse', '--absolute-git-dir'], { cwd: wtPath, check: false });
+    const freshHead = runGit(['rev-parse', 'HEAD'], { cwd: wtPath, check: false });
+    if (!Array.isArray(freshActive) || worktreeHasActiveProcess(wtPath, freshActive)
+        || !freshCounts || freshCounts.staged || freshCounts.unstaged || freshCounts.untracked
+        || freshIgnored.status !== 0 || freshIgnored.stdout || !freshMatch || Number(freshMatch[1]) !== kib
+        || gitdir.status !== 0 || !gitdir.stdout.trim() || fs.existsSync(path.join(gitdir.stdout.trim(), 'locked'))
+        || freshHead.status !== 0 || String(freshHead.stdout || '').trim() !== wt.head
+        || runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status !== 0
+        || !originBaseIsCurrent(root, base)
+        || canonicalPath(wtPath) !== wtPath) {
+      kept.push({ ...item, reason: 'changed_or_active_during_verification' });
+      continue;
+    }
+    const removedResult = runGit(['worktree', 'remove', wt.path], { cwd: root, check: false });
     if (removedResult.status === 0) {
       removed.push(candidate);
       recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason });
@@ -1465,10 +1553,13 @@ function cleanup(args) {
   for (const item of result.apply ? result.removed : result.candidates) {
     console.log(`${action}: ${item.path} branch=${item.branch} reason=${item.reason}`);
   }
-  const cacheAction = result.apply ? 'cache_pruned' : 'cache_candidate';
-  console.log(`${cacheAction}s: ${result.apply ? result.cachePruned.length : result.cacheCandidates.length}`);
-  for (const item of result.apply ? result.cachePruned : result.cacheCandidates) {
-    console.log(`${cacheAction}: ${item.path}`);
+  const review = result.cacheCandidates.filter((item) => item.reason === 'manual_review_required');
+  const safe = result.apply ? result.cachePruned : result.cacheCandidates.filter((item) => item.reason === 'generated_webpack_cache');
+  console.log(`cache ${result.apply ? 'removed' : 'candidate'}s: ${safe.length}`);
+  for (const item of safe) console.log(`cache: ${item.path} size_kib=${item.kib}`);
+  console.log(`cache review needed: ${review.length}`);
+  for (const item of review) {
+    console.log(`review: ${item.path} reason=${item.reason}`);
   }
   console.log(`kept: ${result.kept.length}`);
   if (!result.apply && result.candidates.length) console.log('next: atris worktree cleanup --apply');
@@ -1524,7 +1615,7 @@ function help() {
   console.log('  atris worktree status');
   console.log('  atris worktree guard [--allow-primary] [--allow-dirty]');
   console.log('  atris worktree prune [--apply]');
-  console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]  reap completed checkouts and ignored build caches');
+  console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]  reap completed checkouts and verified webpack caches');
 }
 
 function worktreeCommand(args = []) {

package/lib/atris-rating-combine.json

@@ -0,0 +1,77 @@
+{
+ "bench": "Loop Bench",
+ "rated": "2026-10-29",
+ "tasks": 80,
+ "unseen": 32,
+ "engines": [
+  {
+   "model": "claude-opus-5-5",
+   "tasks": 80,
+   "finished": 77.0,
+   "python": {
+    "finished": 35.0,
+    "tasks": 36
+   },
+   "javascript": {
+    "finished": 42.0,
+    "tasks": 44
+   },
+   "unseen": {
+    "finished": 31.0,
+    "tasks": 32
+   },
+   "tries": 83,
+   "broke": 1,
+   "timed_out": 1,
+   "minutes_cap": 20,
+   "median_minutes": 2.23,
+   "cost_per_finish": 0.914
+  },
+  {
+   "model": "claude-sonnet-5-5",
+   "tasks": 79,
+   "finished": 73.0,
+   "python": {
+    "finished": 33.6,
+    "tasks": 35
+   },
+   "javascript": {
+    "finished": 39.4,
+    "tasks": 44
+   },
+   "unseen": {
+    "finished": 27.0,
+    "tasks": 32
+   },
+   "tries": 140,
+   "broke": 3,
+   "timed_out": 5,
+   "minutes_cap": 10,
+   "median_minutes": 1.46,
+   "cost_per_finish": 0.428
+  },
+  {
+   "model": "claude-haiku-5-5",
+   "tasks": 80,
+   "finished": 70.5,
+   "python": {
+    "finished": 30.8,
+    "tasks": 36
+   },
+   "javascript": {
+    "finished": 39.8,
+    "tasks": 44
+   },
+   "unseen": {
+    "finished": 27.2,
+    "tasks": 32
+   },
+   "tries": 545,
+   "broke": 8,
+   "timed_out": 87,
+   "minutes_cap": 10,
+   "median_minutes": 2.48,
+   "cost_per_finish": 0.082
+  }
+ ]
+}

package/lib/atris-rating.js

@@ -0,0 +1,179 @@
+'use strict';
+
+// The Atris Rating: one number, 25 to 99, for how much real work a teammate
+// finishes. 99 means 99 of every 100. Each time a teammate halves its misses
+// it gains about 6 points, so the top is the hardest climb: going from 96 to
+// 99 percent finished is worth about 12.
+//
+// One scale rates two things. An engine gets its number from the combine
+// below: real tasks graded by the tests that shipped with them. A member
+// gets its number from the jobs it lands in its own workspace (gm-season).
+
+const { modelLabel } = require('./roster-models');
+
+const TOP = 99;
+const FLOOR = 25;
+const STEP = 6;
+
+// Every rating starts from half a finish and half a miss, so a short perfect
+// run cannot reach the top: 3 of 3 rates 76, and it takes about 60 in a row
+// to rate 99. null when nothing has been tried.
+function atrisRating(finished, tries) {
+  const all = Number(tries);
+  const done = Number(finished);
+  if (!Number.isFinite(all) || all <= 0 || !Number.isFinite(done)) return null;
+  const share = (Math.min(Math.max(done, 0), all) + 0.5) / (all + 1);
+  const raw = TOP - STEP * (Math.log2(TOP) - Math.log2(share / (1 - share)));
+  return Math.max(FLOOR, Math.min(TOP, Math.round(raw)));
+}
+
+// The combine: Loop Bench, tasks from the atris repos (javascript from the
+// CLI, python from the backend), each graded by the hidden tests that shipped
+// with its fix, run in Claude Code on the builder prompt Atris kept. unseen
+// tasks were held out of every prompt change, so the prompt was never tuned
+// on them. finished adds each task's pass rate over its tries; time and price
+// count each task once too. broke counts tries that passed their own tests
+// but broke another one. The file is what evals/loopbench/combine.py in
+// atrisos-backend prints, copied as is, so re-rating is one copy.
+function freeze(value) {
+  if (value && typeof value === 'object') {
+    for (const inner of Object.values(value)) freeze(inner);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+const COMBINE = freeze(require('./atris-rating-combine.json'));
+
+const MONTHS = ['January', 'February', 'March', 'April', 'May', 'June', 'July',
+  'August', 'September', 'October', 'November', 'December'];
+
+// "2026-10-29" -> "October 2026"
+function monthOf(date) {
+  const [year, month] = String(date || '').split('-').map(Number);
+  return year && month >= 1 && month <= 12 ? `${MONTHS[month - 1]} ${year}` : '';
+}
+
+const RATED = monthOf(COMBINE.rated);
+
+// One engine's card: the overall and four parts, each on the same scale.
+function engineCard(row) {
+  return {
+    model: row.model,
+    label: modelLabel(row.model),
+    ovr: atrisRating(row.finished, row.tasks),
+    finished: row.finished,
+    tasks: row.tasks,
+    python: atrisRating(row.python.finished, row.python.tasks),
+    javascript: atrisRating(row.javascript.finished, row.javascript.tasks),
+    unseen: atrisRating(row.unseen.finished, row.unseen.tasks),
+    clean: atrisRating(row.tries - row.broke, row.tries),
+    parts: { python: row.python, javascript: row.javascript, unseen: row.unseen },
+    tries: row.tries,
+    broke: row.broke,
+    minutes_cap: row.minutes_cap,
+    median_minutes: row.median_minutes,
+    cost_per_finish: row.cost_per_finish,
+  };
+}
+
+// Every rated engine, best first.
+function combineCards() {
+  return COMBINE.engines.map(engineCard).sort((a, b) => b.ovr - a.ovr || a.label.localeCompare(b.label));
+}
+
+// The card for a model id, a label, or a family word that names one engine;
+// null for a model the combine has not rated.
+function combineCardFor(name) {
+  const text = String(name || '').trim().toLowerCase().replace(/\s+/g, ' ');
+  if (!text) return null;
+  const cards = combineCards();
+  const exact = cards.find((card) => card.model === text || card.label === text);
+  if (exact) return exact;
+  const family = cards.filter((card) => card.label.split(' ')[0] === text);
+  return family.length === 1 ? family[0] : null;
+}
+
+function finishedText(value) {
+  return Number.isInteger(value) ? String(value) : String(Math.round(value * 10) / 10);
+}
+
+function priceText(dollars) {
+  if (typeof dollars !== 'number') return '-';
+  return dollars < 1 ? `${Math.round(dollars * 100)}¢` : `$${dollars.toFixed(2)}`;
+}
+
+function minutesText(minutes) {
+  return typeof minutes === 'number' ? `${minutes.toFixed(1)} min` : '-';
+}
+
+const SCALE_LINES = Object.freeze([
+  'how much real work a teammate finishes, 25 to 99. 99 means 99 of every 100.',
+  'each halving of misses is worth about 6 points, so the top is the hardest climb.',
+]);
+
+// The league table: every rated engine, best first.
+function renderCombine(cards = combineCards()) {
+  const caps = [...new Set(cards.map((card) => card.minutes_cap))];
+  const capLine = caps.length > 1
+    ? cards.filter((card) => card.minutes_cap !== Math.min(...caps)).map((card) => `${card.label} gets ${card.minutes_cap} minutes a task`).join(', ') + `, the others ${Math.min(...caps)}.`
+    : `every engine gets ${caps[0]} minutes a task.`;
+  const lines = [
+    'atris rating',
+    ...SCALE_LINES,
+    '',
+    `the combine: ${COMBINE.tasks} atris tasks, each graded by the tests that shipped with it`,
+    '',
+    `  ${'ovr'.padEnd(5)}${'engine'.padEnd(12)}${'finished'.padEnd(12)}${'py'.padEnd(4)}${'js'.padEnd(4)}${'unseen'.padEnd(8)}${'clean'.padEnd(7)}${'time'.padEnd(9)}price`,
+  ];
+  for (const card of cards) {
+    lines.push(`  ${String(card.ovr).padEnd(5)}${card.label.padEnd(12)}${`${finishedText(card.finished)} of ${card.tasks}`.padEnd(12)}${String(card.python).padEnd(4)}${String(card.javascript).padEnd(4)}${String(card.unseen).padEnd(8)}${String(card.clean).padEnd(7)}${minutesText(card.median_minutes).padEnd(9)}${priceText(card.cost_per_finish)}`);
+  }
+  const top = cards[0];
+  lines.push(
+    '',
+    top && top.ovr >= TOP ? `${top.label} is a 99.` : 'no engine is a 99 yet.',
+    'py, js: python and javascript tasks. unseen: ones the prompt was never tuned on.',
+    'clean: tries that broke no other test. time: median to finish.',
+    'price: per finished task, pay-per-use.',
+    capLine,
+    `${COMBINE.bench}, ${RATED}. one engine: atris rating <engine>`,
+  );
+  return lines.join('\n');
+}
+
+// One engine's card.
+function renderCard(card) {
+  const head = `${card.label}, builder`;
+  const part = (name, value, text) => `  ${name.padEnd(13)}${String(value).padEnd(5)}${text}`;
+  return [
+    `${head}${' '.repeat(Math.max(2, 44 - head.length))}${card.ovr} ovr`,
+    '',
+    part('python', card.python, `${finishedText(card.parts.python.finished)} of ${card.parts.python.tasks} tasks`),
+    part('javascript', card.javascript, `${finishedText(card.parts.javascript.finished)} of ${card.parts.javascript.tasks} tasks`),
+    part('unseen', card.unseen, `${finishedText(card.parts.unseen.finished)} of ${card.parts.unseen.tasks} tasks the Atris prompt was never tuned on`),
+    part('clean', card.clean, `broke another test on ${card.broke} of ${card.tries} tries`),
+    '',
+    `  finished ${finishedText(card.finished)} of ${card.tasks} tasks, ${minutesText(card.median_minutes)} median, ${card.minutes_cap} minute cap`,
+    `  ${priceText(card.cost_per_finish)} per finished task on pay-per-use`,
+    `  ${COMBINE.bench}, ${RATED}, ${card.tries} tries graded by each task's shipped tests`,
+  ].join('\n');
+}
+
+// What the boot team line adds after a build engine, like " (86 ovr)", or ''
+// for a model the combine has not rated.
+function bootRatingText(model) {
+  const card = model ? combineCards().find((c) => c.model === String(model).trim()) : null;
+  return card ? ` (${card.ovr} ovr)` : '';
+}
+
+module.exports = {
+  COMBINE,
+  SCALE_LINES,
+  atrisRating,
+  bootRatingText,
+  combineCardFor,
+  combineCards,
+  renderCard,
+  renderCombine,
+};