atris 3.74.24 → 3.74.25

package/README.md

@@ -459,6 +459,22 @@ atris scorecard run --models haiku,opus    # compare models; past Haiku needs AT
 - 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

@@ -652,6 +652,7 @@ function showHelpAll() {
   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');
@@ -2239,6 +2240,10 @@ if (command === 'guide') {
   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/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,
+};

package/lib/gm-bet.js

@@ -4573,8 +4573,8 @@ function createBetDesk(deps) {
 
   // The team page: every member on the team, one row each. role is a few
   // words from its MEMBER.md. ovr is the board's own rating (atris gm
-  // --board): 60 to 99 from the share of finished jobs that landed in the
-  // last 30 days, "new" with 1 or 2 finished, and two dots with none
+  // --board): the Atris Rating, 25 to 99, of the finished jobs that landed
+  // in the last 30 days, "new" with 1 or 2 finished, and two dots with none
   // finished in that window (a first claim alone is not a rating) or no
   // task list to read. engine is the tool and the exact model the roster
   // gives the member (atris engine roster), two dots when no model is

package/lib/gm-season.js

@@ -10,6 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { atrisRating } = require('./atris-rating');
 
 const HOUR_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * HOUR_MS;
@@ -49,17 +50,18 @@ function tally(outcomes) {
   return out;
 }
 
-// round(60 + 39 * landed / finished), rookie under 3 finished jobs. This is
+// The Atris Rating of landed over finished (lib/atris-rating.js): 25 to 99,
+// where 99 means 99 of every 100, rookie under 3 finished jobs. This is
 // stricter than the website rule (kept / graded) on purpose: drops and
 // abandoned jobs count.
 function ovr(outcomes) {
   const { landed, finished } = tally(outcomes);
   if (finished < ROOKIE_FINISHED) return null;
-  return Math.round(60 + 39 * landed / finished);
+  return atrisRating(landed, finished);
 }
 
 // Each member's rating over one window of plays, the board's own numbers:
-// ovr is 60 to 99, or null for a rookie under 3 finished. A member with no
+// ovr is 25 to 99, or null for a rookie under 3 finished. A member with no
 // plays in the window is not in the map.
 function memberRatings(outcomes = []) {
   const groups = new Map();

package/lib/known-commands.js

@@ -3,7 +3,7 @@
 const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'idea', 'done', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', '99', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'sync-checkout', 'zen',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 

package/lib/team-lineup.js

@@ -6,6 +6,7 @@
 
 const { modelLabel } = require('./roster-models');
 const { rosterToolLabel } = require('./engine-registry');
+const { bootRatingText } = require('./atris-rating');
 const { suggestionCount } = require('./roster-suggest');
 
 const BUILT_IN_JOBS = Object.freeze(['build', 'review', 'search']);
@@ -52,6 +53,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.
+// A build job's model shows its combine rating (atris rating), since the
+// combine grades building only.
 // 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 } = {}) {
@@ -63,7 +66,9 @@ function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs
   const ordered = orderJobs(rows);
   const part = (row) => {
     const text = shortRuns(row.now_runs);
-    return text ? `${row.job} ${text}` : '';
+    if (!text) return '';
+    const rated = row.role === 'executor' ? bootRatingText(row.now_runs.model) : '';
+    return `${row.job} ${text}${rated}`;
   };
   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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.24",
+  "version": "3.74.25",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",