atris 3.74.24 → 3.74.26

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');
@@ -1893,6 +1895,8 @@ function wakeableMember(args) {
 }
 
 async function gmCommand(...args) {
+  const leaseDb = require('../lib/task-db');
+  try { leaseDb.sweepExpiredLeases(); } catch (_) { /* Existing views report unreadable databases. */ }
   // the walk has its own help
   if (positional(args)[0] === 'walk') {
     const at = args.indexOf('walk');

package/commands/rating.js

@@ -0,0 +1,166 @@
+'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()) || {};
+    const reasons = new Map();
+    for (const play of played.outcomes || []) {
+      if (play.member === row.name && ['dropped', 'sent_back', 'abandoned'].includes(play.kind) && play.reason) {
+        reasons.set(play.reason, (reasons.get(play.reason) || 0) + 1);
+      }
+    }
+    const miss_reasons = [...reasons].map(([reason, count]) => ({ reason, count }))
+      .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason)).slice(0, 3);
+    return { member: row.name, ovr: row.ovr, landed: row.landed, finished: row.finished, job: seat.job || null, model: seat.model || null, ...(miss_reasons.length ? { miss_reasons } : {}) };
+  });
+  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 (m.miss_reasons && m.miss_reasons.length) {
+    lines.push('  top miss reasons:');
+    for (const item of m.miss_reasons) lines.push(`  ${item.count}: ${item.reason}`);
+  }
+  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 taskDb = require('../lib/task-db');
+  taskDb.sweepExpiredLeases();
+  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/task.js

@@ -208,6 +208,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task auto-accept-certified --dry-run [--strict-verify] [--all] [--limit <n>]
                                            Preview certified Review rows; live accept needs --confirm-human-accept --as <human>
   atris task sweep --auto-accept [--json]   Auto-accept verified Review rows; protected lanes wait for human
+  atris task sweep [--json] [--stale-days N] [--claimer NAME] [--dry-run]   Release expired claims
   atris task audit [--limit <n>] [--revise] re-run stored verifies for newest accepted tasks; report-only unless --revise
   atris task revise <id> --note "..."      Send reviewed work back to Do
 
@@ -6252,7 +6253,10 @@ function cmdClaim(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task claim');
-  const result = taskDb.claimTask(db, { id: taskId, claimedBy: String(owner) });
+  const leaseMinutes = flag(args, '--lease-minutes');
+  const leasePid = flag(args, '--lease-pid');
+  if (leaseMinutes != null && (!Number.isFinite(Number(leaseMinutes)) || Number(leaseMinutes) <= 0 || !Number.isInteger(Number(leasePid)) || Number(leasePid) <= 0)) throw new Error('invalid claim lease');
+  const result = taskDb.claimTask(db, { id: taskId, claimedBy: String(owner), ...(leaseMinutes == null ? {} : { leaseMinutes: Number(leaseMinutes), leasePid: Number(leasePid) }) });
   if (result.claimed) {
     const { projection, outPath } = writeDefaultProjection(taskDb, db);
     if (wantsJson(args)) {
@@ -10801,11 +10805,23 @@ function evaluateSweepAutoAccept(task, root, includeProtected = false) {
 
 function cmdSweep(args) {
   if (!hasFlag(args, '--auto-accept')) {
-    failTask(
-      'atris task sweep',
-      'missing_auto_accept',
-      'atris task sweep currently requires --auto-accept for the explicit verified accept policy',
-    );
+    const taskDb = getTaskDb();
+    const staleRaw = flag(args, '--stale-days');
+    if (staleRaw === true || (staleRaw != null && (!Number.isFinite(Number(staleRaw)) || Number(staleRaw) < 0))) throw new Error('stale days must be a nonnegative number');
+    const claimer = flag(args, '--claimer');
+    if (claimer === true) throw new Error('claimer requires a name');
+    const dryRun = hasFlag(args, '--dry-run');
+    const options = { staleDays: staleRaw == null ? undefined : Number(staleRaw), claimer };
+    const tasks = dryRun ? taskDb.previewExpiredLeases(options) : taskDb.expireLeases(taskDb.open(), options);
+    const groups = {};
+    for (const task of tasks) (groups[task.claimed_by] ||= []).push(task);
+    if (wantsJson(args)) printJson({ dry_run: dryRun, groups, tasks });
+    else if (!tasks.length) console.log(dryRun ? 'no claims would be released' : 'no claims released');
+    else for (const [name, entries] of Object.entries(groups)) {
+      console.log(`${name}: ${entries.length} ${dryRun ? 'would be released' : 'released'}`);
+      for (const entry of entries) console.log(`  ${entry.title}: ${entry.reason}`);
+    }
+    return;
   }
   // Sweep has no dry-run implementation: every successful invocation can
   // write accepts, even when an unrecognized --dry-run flag is supplied.
@@ -13076,6 +13092,11 @@ function cmdServe(args) {
 
 async function runTaskCommand(args) {
   const raw = args || [];
+  // A dry run must not mutate even already-expired leases.
+  if (!raw.includes('--dry-run') && !(raw[0] === 'sweep' && !raw.includes('--auto-accept'))) {
+    const taskDb = getTaskDb();
+    taskDb.sweepExpiredLeases();
+  }
   if (raw.includes('--help') || raw.includes('-h')) return help();
   const first = raw[0];
   if (!first) return cmdFirstMinute();
@@ -13273,7 +13294,7 @@ async function run(args) {
     return;
   }
   const result = await runTaskCommand(raw);
-  const skipsRender = sub === 'clear-done' && hasFlag(raw, '--dry-run');
+  const skipsRender = hasFlag(raw, '--dry-run');
   if (MUTATING_TASK_COMMANDS.has(sub) && !skipsRender) autoRenderTodoFromDb();
   return result;
 }