atris 3.74.23 → 3.74.25

package/README.md

@@ -442,6 +442,39 @@ Under the hood, Atris can keep score on real repo work.
 - `atris autopilot` can run that check after review and record the result in the journal.
 - Future task picks can use recent results, so Atris learns from repo-local history without claiming model retraining.
 
+## Which AI Can Do Your Work
+
+`atris scorecard` measures which AI can do your team's work, on your own repo.
+
+```bash
+atris scorecard                            # find past changes whose own tests can grade an AI (no AI runs)
+atris scorecard run                        # try each one with Haiku on your Claude plan
+atris scorecard run --models haiku,opus    # compare models; past Haiku needs ATRIS_CLAUDE_SPEND_OK=<model>
+```
+
+- A past change becomes a task when its tests fail before it and pass after it. The ask is what your team wrote for that change.
+- The ask also names what the change's tests call that the change added or changed: a new file, a function with its arguments, an export, found with no AI. A good ticket names these; a commit message rarely does, and no model can guess a name nobody wrote down.
+- Each try starts from the change's parent in a throwaway copy with no remote. The change's own tests stay hidden until they grade the try.
+- Every try runs on your Claude plan login. Pay-per-use keys are removed, a try stops the moment Claude Code reports any other billing source, and nothing starts with extra usage on unless you pass `--allow-extra-usage`.
+- The scorecard shows how many changes each model did, how long it took, what the same runs would cost on pay-per-use, and which changes no model could do from what was written.
+- Tests that need their own command or settings go in `.atris/scorecard.json`.
+
+## The Atris Rating
+
+`atris rating` gives every AI teammate one number, 25 to 99, for how much real work it finishes.
+
+```bash
+atris rating               # every engine the combine rated, and your members here
+atris rating opus          # one engine's card
+atris rating <member>      # one member's rating here, next to its engine's
+```
+
+- 99 means 99 of every 100 finished. Each halving of misses is worth about 6 points, so the top is the hardest climb: 3 in a row rates 76, and it takes about 60 in a row to rate 99.
+- Engines are rated in the combine: Loop Bench tasks from the atris repos, each graded by the tests that shipped with it. No engine is a 99 yet.
+- Each engine's card also rates its Python tasks, its JavaScript tasks, the tasks the Atris prompt was never tuned on, and how rarely a try broke another test, with its median time and pay-per-use price per finished task.
+- Members are rated on the same scale from the jobs they landed in your workspace over the last 30 days. Landed means accepted or merged; drops and abandons count against them. `atris gm` shows the same numbers.
+- The session boot shows the build engine's rating, for example `build opus 5.5 (86 ovr)`. The combine grades building only, so review and search engines show none.
+
 ## Benchmark Harness
 
 Atris ships one public head-to-head benchmark harness for comparing a pinned

package/bin/atris.js

@@ -651,6 +651,8 @@ function showHelpAll() {
   console.log('  meet       - onboard a stranger in one sitting and print their /book link');
   console.log('  avail      - Booking availability (/book/{username} weekly windows)');
   console.log('  scoreboard - Today\'s github contributions vs your best day, streak, repo commits (--watch, --json)');
+  console.log('  scorecard  - Which AI can do your team\'s work: past changes graded by their own tests, run on your Claude plan (find, run, show)');
+  console.log('  rating     - The Atris Rating, 25 to 99: how much real work each engine and member finishes (atris rating opus)');
   console.log('  brain      - Compile MAP/TODO/wiki/state into a loadable agent brain');
   console.log('  lesson     - atris lesson add <slug> <pass|fail> "<text>" (mine/sweep/resolve/revert/ledger; --detector validates the falsifier at write time)');
   console.log('  taste      - Record the operator\'s keep, kill, and more creative verdicts');
@@ -2234,6 +2236,14 @@ if (command === 'guide') {
   Promise.resolve().then(() => require('../commands/scoreboard').scoreboardCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'scorecard') {
+  Promise.resolve().then(() => require('../commands/scorecard').scorecardCommand(process.argv.slice(3)))
+    .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'rating') {
+  Promise.resolve().then(() => require('../commands/rating').ratingCommand(process.argv.slice(3)))
+    .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))
+    .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
 } else if (command === 'meet') {
   Promise.resolve().then(() => require('../commands/meet').meetCommand(process.argv.slice(3)))
     .then((code) => exitAfterStdoutDrain(typeof code === 'number' ? code : 0))

package/commands/gm.js

@@ -41,7 +41,9 @@ function showHelp() {
   console.log('  what is up next. Every job a member takes in the last 30 days ends');
   console.log('  landed (accepted or merged), dropped (claim let go), sent back, or');
   console.log('  abandoned (archived without landing). Jobs in review are pending.');
-  console.log('  ovr = round(60 + 39 * landed / finished), rookie under 3 finished.');
+  console.log('  ovr = the Atris Rating of landed over finished, 25 to 99: 99 means 99');
+  console.log('  of every 100 and each halving of misses is worth about 6 (atris rating).');
+  console.log('  Rookie under 3 finished.');
   console.log('  Drops and abandons count, so this is stricter than the website rating.');
   console.log('  "on a job" means the claimed task moved in the last 6 hours; a claim');
   console.log('  that sat longer shows as stuck, with its age and task id.');
@@ -936,8 +938,8 @@ function renderBoardLines(board, { interactive = false, width = termWidth(), bor
   }
   lines.push('');
 
-  lines.push(`key: ovr 60 to 99 = share of finished jobs landed, ${boxed ? 'new' : 'rookie'} under 3 finished,`);
-  lines.push('     stricter than the website rating on purpose (drops and abandons count)');
+  lines.push(`key: ovr = the Atris Rating of finished jobs landed, 25 to 99, ${boxed ? 'new' : 'rookie'} under 3 finished.`);
+  lines.push('     99 means 99 of every 100. drops and abandons count (atris rating)');
   if (boxed) lines.push('     ·· = nothing to show yet: no finished job, no role, or no pinned model');
   else lines.push('     form: last 5, newest right: k landed, d dropped, x sent back, a abandoned');
   lines.push('     hours: claim to result. on a job: moved in the last 6h. review: pending');

package/commands/rating.js

@@ -0,0 +1,152 @@
+'use strict';
+
+// atris rating: the Atris Rating, one number from 25 to 99 for how much real
+// work a teammate finishes. Engines are rated in the combine (Loop Bench);
+// members are rated on the jobs they land here, the same numbers atris gm
+// shows. Read only: nothing runs and nothing is written.
+
+const { hasFlag } = require('../lib/arg-parser');
+const { modelLabel } = require('../lib/roster-models');
+const rating = require('../lib/atris-rating');
+
+const USAGE = [
+  'usage: atris rating [engine | member] [--json]',
+  '  how much real work each AI teammate finishes, one number from 25 to 99.',
+  '',
+  '  atris rating            every engine the combine rated, and your members here',
+  '  atris rating opus       one engine\'s card (opus, sonnet, haiku, or a model id)',
+  '  atris rating <member>   one member\'s rating here, next to its engine\'s',
+  '  --json                  print it as json',
+].join('\n');
+
+// "an 86", "a 76": eighty-something, eleven, and eighteen start with a vowel.
+function rated(n) {
+  return `${/^(8|11$|18$)/.test(String(n)) ? 'an' : 'a'} ${n}`;
+}
+
+// Members rated on the last 30 days of jobs here, best first, each with the
+// job and model the roster gives it, plus the build line: what the build
+// engine rates in the combine and what members doing build landed here.
+// null when there is no task list or no finished job to rate.
+function readHere(deps = {}) {
+  let root = deps.root;
+  let played = deps.season;
+  try {
+    if (!root) root = require('../lib/task-db').workspaceRoot(process.cwd());
+    if (!played) played = require('../lib/gm-season').loadSeason(root, { lastSeen: null });
+  } catch {
+    return null;
+  }
+  if (!played || played.error || played.no_history) return null;
+  const { rosterRows } = require('../lib/gm-season');
+  const rows = rosterRows({ outcomes: played.outcomes || [], limit: Number.MAX_SAFE_INTEGER }).filter((row) => row.finished > 0);
+  if (!rows.length) return null;
+  let lineup = deps.lineup;
+  if (lineup === undefined) lineup = require('../lib/team-lineup').readLineupSafe(root);
+  const team = new Map(((lineup && lineup.ok && lineup.team) || []).map((row) => [String(row.member || '').toLowerCase(), row]));
+  const members = rows.map((row) => {
+    const seat = team.get(row.name.toLowerCase()) || {};
+    return { member: row.name, ovr: row.ovr, landed: row.landed, finished: row.finished, job: seat.job || null, model: seat.model || null };
+  });
+  const buildJob = ((lineup && lineup.ok && lineup.jobs) || []).find((row) => row.job === 'build' && !row.key);
+  const buildModel = buildJob && buildJob.now_runs ? buildJob.now_runs.model : null;
+  const card = buildModel ? rating.combineCards().find((c) => c.model === buildModel) : null;
+  const builders = members.filter((m) => m.job === 'build');
+  const landed = builders.reduce((sum, m) => sum + m.landed, 0);
+  const finished = builders.reduce((sum, m) => sum + m.finished, 0);
+  return {
+    workspace: played.workspace_name || null,
+    members,
+    build: card && finished ? { model: buildModel, combine_ovr: card.ovr, landed, finished, ovr: rating.atrisRating(landed, finished) } : null,
+  };
+}
+
+function renderHere(here) {
+  const ranked = here.members.filter((m) => m.ovr != null);
+  const fresh = here.members.filter((m) => m.ovr == null);
+  const nameW = Math.min(24, Math.max(6, ...ranked.map((m) => m.member.length))) + 2;
+  const lines = [`here${here.workspace ? `: ${here.workspace}` : ''}, last 30 days, the same ratings as atris gm`, ''];
+  if (ranked.length) {
+    lines.push(`  ${'ovr'.padEnd(5)}${'member'.padEnd(nameW)}${'landed'.padEnd(11)}${'job'.padEnd(8)}model`);
+    for (const m of ranked) {
+      const name = m.member.length > nameW - 2 ? `${m.member.slice(0, nameW - 5)}...` : m.member;
+      lines.push(`  ${String(m.ovr).padEnd(5)}${name.padEnd(nameW)}${`${m.landed} of ${m.finished}`.padEnd(11)}${(m.job || '').padEnd(8)}${m.model ? modelLabel(m.model) : ''}`.trimEnd());
+    }
+  } else {
+    lines.push('  no member has 3 finished jobs here yet');
+  }
+  if (fresh.length) {
+    const names = fresh.map((m) => m.member);
+    const head = `new, under 3 finished jobs (${names.length}): `;
+    const shown = [];
+    for (const name of names) {
+      if (head.length + [...shown, name].join(', ').length + ', and 99 more'.length > 80) break;
+      shown.push(name);
+    }
+    const rest = names.length - shown.length;
+    lines.push('', `${head}${shown.join(', ')}${rest ? `, and ${rest} more` : ''}`);
+  }
+  lines.push('landed: accepted or merged. drops and abandons count against a member.');
+  if (here.build) {
+    const b = here.build;
+    lines.push('', `build runs ${modelLabel(b.model)}, ${rated(b.combine_ovr)} in the combine.`,
+      `members doing build here landed ${b.landed} of ${b.finished} jobs, ${rated(b.ovr)}.`);
+  }
+  return lines.join('\n');
+}
+
+function renderMember(m, card) {
+  const job = m.job ? `, ${m.job}${m.model ? ` on ${modelLabel(m.model)}` : ''}` : '';
+  const head = `${m.member}${job}`;
+  const lines = [
+    `${head}${' '.repeat(Math.max(2, 44 - head.length))}${m.ovr == null ? 'new' : `${m.ovr} ovr`} here`,
+    '',
+    `  landed ${m.landed} of ${m.finished} finished jobs in the last 30 days`,
+  ];
+  if (m.ovr == null) lines.push('  rated once it has 3 finished jobs');
+  if (card && m.job === 'build') lines.push(`  its engine, ${card.label}, is ${rated(card.ovr)} in the combine: atris rating ${card.label.split(' ')[0]}`);
+  lines.push(`  every play: atris gm card ${m.member}`);
+  return lines.join('\n');
+}
+
+function ratingCommand(args = [], deps = {}) {
+  const write = deps.write || ((text) => process.stdout.write(text));
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
+    write(`${USAGE}\n`);
+    return 0;
+  }
+  const json = hasFlag(args, '--json');
+  const name = args.filter((arg) => !arg.startsWith('-')).join(' ').trim();
+  const cards = rating.combineCards();
+  if (name) {
+    const card = rating.combineCardFor(name);
+    if (card) {
+      write(json ? `${JSON.stringify({ schema: 'atris.rating.v1', engine: card }, null, 2)}\n` : `${rating.renderCard(card)}\n`);
+      return 0;
+    }
+    const here = readHere(deps);
+    const member = here && here.members.find((m) => m.member.toLowerCase() === name.toLowerCase());
+    if (member) {
+      const own = member.model ? cards.find((c) => c.model === member.model) || null : null;
+      write(json ? `${JSON.stringify({ schema: 'atris.rating.v1', member, engine: member.job === 'build' ? own : null }, null, 2)}\n` : `${renderMember(member, own)}\n`);
+      return 0;
+    }
+    const err = deps.error || ((text) => process.stderr.write(text));
+    err(`no engine or member called "${name}" is rated. engines: ${cards.map((c) => c.label).join(', ')}. members show once they finish a job here.\n`);
+    return 1;
+  }
+  const here = readHere(deps);
+  if (json) {
+    write(`${JSON.stringify({
+      schema: 'atris.rating.v1',
+      scale: { floor: 25, top: 99, means: rating.SCALE_LINES.join(' ') },
+      combine: { bench: rating.COMBINE.bench, month: rating.COMBINE.month, tasks: rating.COMBINE.tasks, unseen: rating.COMBINE.unseen, engines: cards },
+      here,
+    }, null, 2)}\n`);
+    return 0;
+  }
+  write(`${rating.renderCombine(cards)}${here ? `\n\n${renderHere(here)}` : ''}\n`);
+  return 0;
+}
+
+module.exports = { ratingCommand, USAGE };

package/commands/scorecard.js

@@ -0,0 +1,297 @@
+'use strict';
+
+// atris scorecard: which AI can do your team's work, measured on your own
+// past changes and graded by the tests that shipped with them. Finding tasks
+// runs no AI. Tries run on your Claude plan login, never an API key.
+
+const fs = require('fs');
+const path = require('path');
+const { hasFlag, readFlag, readIntFlag, readNumberFlag } = require('../lib/arg-parser');
+const sc = require('../lib/repo-scorecard');
+
+const USAGE = [
+  'usage: atris scorecard [find | run | show] [options]',
+  '  which AI can do your team\'s work, measured on your own past changes.',
+  '',
+  '  atris scorecard          find tasks the first time, then show the scorecard',
+  '  atris scorecard find     turn past changes into tasks their own tests grade (no AI runs)',
+  '  atris scorecard run      try each task with each model on your Claude plan',
+  '  atris scorecard show     print the scorecard from saved results',
+  '',
+  'find options:',
+  '  --max N          keep at most N tasks (default 12)',
+  '  --scan N         look through the last N changes (default 300)',
+  '  --config FILE    test commands for this repo (default .atris/scorecard.json)',
+  '  --with-env       copy .env files into each copy, read-only, billing keys left out',
+  '',
+  'run options:',
+  '  --models a,b     models to try (default haiku). any model past haiku needs',
+  '                   ATRIS_CLAUDE_SPEND_OK=<model> because it uses much more of your plan',
+  '  --tries N        tries per task and model (default 1). a stopped run picks up where it left off',
+  '  --jobs N         tries at a time (default 2)',
+  '  --minutes N      time limit per try (default 10, 20 for opus and fable)',
+  '  --task ID        only this task (its id or the first characters of its change)',
+  '  --allow-extra-usage  run even when extra usage is on for your Claude account',
+  '',
+  '  --json           print the result as json',
+].join('\n');
+
+function storePaths(root) {
+  const dir = sc.storeDir(root);
+  return { dir, tasks: path.join(dir, 'tasks.json'), results: path.join(dir, 'results.jsonl') };
+}
+
+function readTasks(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readResults(file) {
+  try {
+    return fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function firstLine(text, width) {
+  const line = String(text || '').split('\n')[0];
+  return line.length > width ? `${line.slice(0, width - 3)}...` : line;
+}
+
+const SKIP_WORDS = {
+  no_tests: 'had no tests changed beside the code',
+  too_big: 'were too big for one ask',
+  short_ask: 'had too few words to work from',
+  unknown_runner: 'used a test setup this cannot run yet',
+  fails_after: 'had tests that fail even with the change',
+  passes_before: 'had tests that already passed before the change',
+};
+
+function skipSummary(skipped) {
+  return Object.entries(skipped || {}).filter(([, n]) => n > 0)
+    .map(([key, n]) => `${n} ${SKIP_WORDS[key] || key}`).join(', ');
+}
+
+async function find(root, args, { quiet = false } = {}) {
+  const paths = storePaths(root);
+  const json = hasFlag(args, '--json');
+  const say = (line) => { if (!json && !quiet) console.log(line); };
+  const max = readIntFlag(args, '--max', sc.MAX_TASKS);
+  const scan = readIntFlag(args, '--scan', 300);
+  say(`atris scorecard  ${sc.repoName(root)}`);
+  say(`looking through the last ${scan} changes for ones whose own tests can grade an AI. no AI runs in this step.`);
+  say('');
+  const scratch = sc.workDir(root);
+  let result;
+  try {
+    result = await sc.findTasks(root, {
+      max,
+      scan,
+      configPath: readFlag(args, '--config', '') || undefined,
+      withEnv: hasFlag(args, '--with-env'),
+      workDir: scratch,
+      onCheck: (task, verdict) => {
+        const word = verdict === 'found' ? 'task' : 'skip';
+        const why = verdict === 'found' ? sc.runnerLabel(task.runner) : SKIP_WORDS[verdict];
+        say(`  ${word}  ${task.fix.slice(0, 7)}  ${firstLine(task.ask, 60).padEnd(60)}  ${why}`);
+      },
+    });
+  } finally {
+    sc.stopAll();
+    fs.rmSync(scratch, { recursive: true, force: true });
+  }
+  const saved = {
+    repo: sc.repoName(root),
+    root,
+    found_at: new Date().toISOString(),
+    looked: result.looked,
+    candidates: result.candidates,
+    skipped: result.skipped,
+    tasks: result.tasks,
+  };
+  fs.mkdirSync(paths.dir, { recursive: true });
+  fs.writeFileSync(paths.tasks, `${JSON.stringify(saved, null, 2)}\n`);
+  if (json) {
+    console.log(JSON.stringify(saved, null, 2));
+    return 0;
+  }
+  if (!quiet) {
+    say('');
+    say(`found ${result.tasks.length} ${result.tasks.length === 1 ? 'task' : 'tasks'} in ${result.looked} past changes.`);
+    const skips = skipSummary(result.skipped);
+    if (skips) say(`the rest ${skips}.`);
+    if (!result.tasks.length) {
+      say('');
+      say('if your tests need a command or settings to run, put them in .atris/scorecard.json, for example:');
+      say('  {"tests": [{"match": "^backend/", "dir": "backend", "cmd": "python -m pytest -q {files}", "env": {"ENV": "test"}}]}');
+      return 1;
+    }
+    say('');
+    say('next: atris scorecard run');
+    say(`  tries each task with ${sc.shortModel(sc.DEFAULT_MODELS[0])} on your Claude plan, up to 10 minutes each, 2 at a time.`);
+  }
+  return result.tasks.length ? 0 : 1;
+}
+
+function pickTasks(saved, args) {
+  const only = readFlag(args, '--task', '');
+  if (!only) return saved.tasks;
+  return saved.tasks.filter((task) => task.id === only || task.id.startsWith(only) || task.fix.startsWith(only));
+}
+
+async function run(root, args) {
+  const paths = storePaths(root);
+  const json = hasFlag(args, '--json');
+  const say = (line) => { if (!json) console.log(line); };
+  let saved = readTasks(paths.tasks);
+  if (!saved) {
+    say('no tasks yet, so finding them first.');
+    say('');
+    const code = await find(root, args.filter((a) => a !== '--json'), { quiet: json });
+    if (code !== 0) return code;
+    saved = readTasks(paths.tasks);
+    say('');
+  }
+  const tasks = pickTasks(saved, args);
+  if (!tasks.length) {
+    console.error(saved.tasks.length ? 'no task matches --task.' : 'there are no tasks to run. try atris scorecard find --scan 1000');
+    return 1;
+  }
+  const models = sc.normalizeModels(readFlag(args, '--models', ''));
+  let login;
+  try {
+    login = sc.preflight(models, { allowExtraUsage: hasFlag(args, '--allow-extra-usage') });
+  } catch (err) {
+    console.error(err.message || String(err));
+    return 1;
+  }
+  const tries = Math.max(1, readIntFlag(args, '--tries', 1) || 1);
+  const jobs = Math.max(1, readIntFlag(args, '--jobs', 2) || 2);
+  const minutes = readNumberFlag(args, '--minutes', null);
+  const before = readResults(paths.results);
+  const names = models.map(sc.shortModel).join(', ');
+  say(`atris scorecard run  ${sc.repoName(root)}`);
+  say(`${tasks.length} ${tasks.length === 1 ? 'task' : 'tasks'} x ${names}, ${tries} ${tries === 1 ? 'try' : 'tries'} each, ${jobs} at a time.`);
+  say(`on your ${login.plan}. pay-per-use keys are removed from every run${login.extraUsage ? '' : ', so this bills $0'}.`);
+  say('');
+
+  const scratch = sc.workDir(root);
+  const cleanup = () => {
+    sc.stopAll();
+    fs.rmSync(scratch, { recursive: true, force: true });
+  };
+  const onSignal = () => {
+    cleanup();
+    console.error('\nstopped. finished tries are saved; run the same command to pick up where it left off.');
+    process.exit(130);
+  };
+  process.once('SIGINT', onSignal);
+  process.once('SIGTERM', onSignal);
+  let outcome;
+  try {
+    outcome = await sc.runAll(root, tasks, {
+      models,
+      tries,
+      jobs,
+      minutes,
+      bin: login.bin,
+      withEnv: hasFlag(args, '--with-env'),
+      done: before,
+      workDir: scratch,
+      outDir: paths.dir,
+      onResult: (row) => {
+        fs.appendFileSync(paths.results, `${JSON.stringify(row)}\n`);
+        const task = tasks.find((t) => t.id === row.id) || { fix: row.id, ask: '' };
+        let word = row.passed ? 'pass' : 'fail';
+        let note = row.timed_out ? `${row.limit_minutes} min (time limit)` : `${row.minutes} min`;
+        if (row.engine_error) { word = 'skip'; note = firstLine(row.engine_tail, 50) || 'claude did not finish'; }
+        if (row.harness_error) { word = 'skip'; note = firstLine(row.harness_error, 50); }
+        say(`  ${word}  ${sc.shortModel(row.model).padEnd(10)}  ${task.fix.slice(0, 7)}  ${firstLine(task.ask, 50).padEnd(50)}  ${note}`);
+      },
+    });
+  } finally {
+    process.removeListener('SIGINT', onSignal);
+    process.removeListener('SIGTERM', onSignal);
+    cleanup();
+  }
+  const rows = readResults(paths.results);
+  const summary = sc.summarize(saved.tasks, rows, models);
+  if (json) {
+    console.log(JSON.stringify({ ...summary, stopped: outcome.stopped, ran: outcome.rows.length }, null, 2));
+    return outcome.stopped ? 1 : 0;
+  }
+  if (!outcome.planned) say('every try asked for is already done.');
+  say('');
+  console.log(sc.renderScorecard(summary, { repo: sc.repoName(root), plan: login.plan, extraUsage: login.extraUsage }));
+  if (outcome.stopped) {
+    const billed = outcome.rows.find((row) => row.not_plan);
+    say('');
+    say(billed
+      ? `stopped: ${billed.engine_tail} log in to your Claude plan with \`claude\` then /login, and run it again.`
+      : 'stopped early: your Claude plan hit its usage limit. run the same command after it resets to finish.');
+    return 1;
+  }
+  return 0;
+}
+
+function show(root, args) {
+  const paths = storePaths(root);
+  const saved = readTasks(paths.tasks);
+  if (!saved) {
+    console.error('no scorecard yet. run: atris scorecard find');
+    return 1;
+  }
+  const rows = readResults(paths.results);
+  const summary = sc.summarize(saved.tasks, rows);
+  if (hasFlag(args, '--json')) {
+    console.log(JSON.stringify(summary, null, 2));
+    return 0;
+  }
+  if (!rows.some((row) => saved.tasks.some((task) => task.id === row.id))) {
+    console.log(`atris scorecard  ${saved.repo}`);
+    console.log(`${saved.tasks.length} tasks found, none tried yet:`);
+    for (const task of saved.tasks) console.log(`  ${task.fix.slice(0, 7)}  ${firstLine(task.ask, 80)}`);
+    console.log('');
+    console.log('next: atris scorecard run');
+    return 0;
+  }
+  const login = sc.planLogin();
+  console.log(sc.renderScorecard(summary, { repo: saved.repo, plan: login.ok ? login.plan : '', extraUsage: login.extraUsage }));
+  return 0;
+}
+
+async function scorecardCommand(args = []) {
+  if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
+    console.log(USAGE);
+    return 0;
+  }
+  let root;
+  try {
+    root = sc.repoRoot();
+  } catch {
+    console.error('atris scorecard works inside a git repo. cd into one and try again.');
+    return 1;
+  }
+  const sub = args[0] && !args[0].startsWith('-') ? args[0] : '';
+  const rest = sub ? args.slice(1) : args;
+  if (sub === 'find') return find(root, rest);
+  if (sub === 'run') return run(root, rest);
+  if (sub === 'show') return show(root, rest);
+  if (sub) {
+    console.error(`unknown step "${sub}".\n\n${USAGE}`);
+    return 1;
+  }
+  if (!readTasks(storePaths(root).tasks)) {
+    const code = await find(root, rest);
+    return code;
+  }
+  return show(root, rest);
+}
+
+module.exports = { scorecardCommand, USAGE };

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
+  }
+ ]
+}