atris 3.76.0 → 3.78.0

package/README.md

@@ -433,6 +433,8 @@ atris mission run --fleet --slots 3          # staff up to 3 engines
 atris mission run --fleet --dry-run          # preview the staffing only
 ```
 
+Each job goes to the builder its real results favor. The fleet counts what each engine landed and missed since Nov 1, on jobs like this one and on the rest (the same plays `atris rating` shows), gives every engine a fair chance, and prints the pick under the job with the numbers behind it. A landing counts only when its commit is on origin's default branch (the branch `origin/HEAD` names, never a guess), is no older than the claim it lands (five minutes of clock skew allowed), and no other claim recorded the same commit first: a commit counts once, for the first claim that recorded it, and not again for a later claim on the same job (reopened and claimed again, by the same engine or another) or for another job. That is judged on every landing record in the task store, in every workspace that shares it and every later review pass. A landing pays the engine that finished the job: when a stalled or dead engine's job is finished by another, the engine that finished it is credited, and a landing whose hand-in names several engines without saying which finished counts for none. The folder is judged in one order. With no git, no origin, or `origin/HEAD` not set (`git remote set-head origin --auto` sets it), no landing can be checked, so jobs are dealt in turn and the flight says why in one line. With an engine's landing on record, the flight fetches origin's default branch once before it picks (so a merge from a minute ago counts); if that fetch fails, jobs are dealt in turn with one line, and if it works the landings are checked. With only misses on record, they steer on their own, with no fetch. Everything git does before a pick shares one five-second budget and never prompts: its input is closed, `GIT_TERMINAL_PROMPT` is 0, and ssh runs in batch mode unless you set your own ssh command, which is left as it is and mentioned in one line. A play counts toward the kind of job it was when the engine took it: the claim, whether made by the fleet or by `task do`, saves the job's title and tags, so tagging or renaming a finished job later changes nothing, and a claim made before that was saved counts at half weight. New engines get tried; engines that keep missing get fewer jobs. An engine that is out of credit, cooling, or one the Claude spend guard would stop (a paid model nobody approved, or a pay-per-use key) is never picked, and the flight says which. The guard's own hook (`atris spend guard install`) stays the real guard on every unattended Claude run; this check only avoids picking an engine the hook would refuse, so where it is unsure it leaves Claude out. The fleet's own launch is judged by the `--model` the fleet itself passes, read through the `ANTHROPIC_DEFAULT_*_MODEL` remaps in the environment the worker will really get (a sealed one-lap worker gets none); with no `--model`, by `ANTHROPIC_MODEL` in that same environment, else the paid default. No Claude settings file is read, from any home. A custom launch template (`ATRIS_RUNNER_COMMAND_TEMPLATE`) is never read for its model, because a model in it can be a flag, a word of the prompt, another command's, or one the shell works out only when it runs. It counts as a model nobody can tell, which counts as paid, so Claude is left out with one line saying so, unless `ATRIS_CLAUDE_SPEND_OK` approves `default`; `--engine claude` still uses it. Your own choices come first and are never picked for, with results or without: `--engine <name>` sends every job to one engine, a job that names its engine gets it, and a job assigned to a member goes to that member's own engine, the same one `atris member` uses. A choice the flight cannot give is never given to someone else: a job that names an engine this flight does not have, or whose member's engine it does not have, is left out of the flight, with one line naming the job and why. It is taken out before the flight is staffed, so it takes no slot and holds no file against another job. The pick goes on who a job is assigned to and the engine it names, as the task list showed them; the claim asks the store for both again, inside its own transaction, and a job that now says something else is not claimed for the old choice. It is left for the next flight with one line, and the task list is drawn again so that flight reads the job as it is now. An engine list you name is never filtered, on the first pick or on a retry. If an engine dies mid-job, the next one is picked the same way; if it stalls and the roster lists a backup order, the roster's order stands. `--pick turns` (or `ATRIS_PICK=turns`) deals engines in turn, as before.
+
 ## Verifiable Feedback Loop
 
 Under the hood, Atris can keep score on real repo work.

package/commands/brief.js

@@ -15,9 +15,12 @@ const {
 } = require('../lib/brief-ledger');
 const { renderHtml } = require('../lib/html-render');
 const { nextMoves, recordDecision, seedInboxFromMove } = require('../lib/next-moves');
+const { SHOWN, buildOwnerBrief, cutAtSpace, ownerBlocks, printableLink, redacted, renderOwnerText } = require('../lib/owner-brief');
 const { buildWeekReportData, renderWeekReport } = require('./report');
 
 const DAY_MS = 24 * 60 * 60 * 1000;
+// Titles on the owner's screen stay on one line.
+const OWNER_TITLE_MAX = 90;
 const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json');
 const NEEDS_HUMAN_TAGS = new Set(['needs-human', 'human-review', 'human', 'manual', 'protected', 'denied']);
 
@@ -62,6 +65,29 @@ function outputText(value, fallback = '') {
   return inlineText(value, fallback).toLowerCase();
 }
 
+// A link or a path is one word. Any word with a / in it counts, and the brackets, quotes, and
+// sentence marks around it are not part of it. The shortener keeps such a word whole or drops
+// it whole and never leaves a piece of one: a title must not end in `feature/` or in
+// `Review https`. `start` and `end` are the word itself, `from` and `to` the word with what
+// is around it.
+const WRAP_OPEN = '([{<"\'`';
+const WRAP_CLOSE = ')]}>"\'`.,;:!?';
+
+function slashWords(text) {
+  const found = [];
+  const word = /\S+/g;
+  for (let match = word.exec(text); match; match = word.exec(text)) {
+    const from = match.index;
+    const to = from + match[0].length;
+    let start = from;
+    let end = to;
+    while (start < end && WRAP_OPEN.includes(text[start])) start += 1;
+    while (end > start && WRAP_CLOSE.includes(text[end - 1])) end -= 1;
+    if (text.slice(start, end).includes('/')) found.push({ start, end, from, to });
+  }
+  return found;
+}
+
 function finishText(value, max = 150) {
   const clean = inlineText(value, '');
   if (clean.length <= max) return clean;
@@ -71,28 +97,73 @@ function finishText(value, max = 150) {
   const clause = Math.max(cut.lastIndexOf('; '), cut.lastIndexOf(', '), cut.lastIndexOf(': '));
   if (clause > max * 0.45) return cut.slice(0, clause).trim();
   const space = cut.lastIndexOf(' ');
-  return cut.slice(0, space > max * 0.55 ? space : max).trim();
+  let at = space > max * 0.55 ? space : max;
+  // The cut fell inside a link or a path, so the line stops before that word and it goes whole.
+  // When it is the first word there is nothing before it: it stays if it fits in twice the
+  // room, and goes if it does not.
+  const across = slashWords(clean).find((word) => word.from < at && at < word.to);
+  if (across) at = across.from > 0 ? across.from : (across.to <= max * 2 ? across.to : 0);
+  return clean.slice(0, at).trim();
+}
+
+// A file name is plumbing and goes whole: a known extension that ends where the word does
+// (`.json` is not `.js` with `on` left over), then the line and column numbers if there are any.
+// Any other link or path is kept whole. Both are set aside while the plumbing is taken out, so
+// nothing in the shortener ever works on a piece of one.
+const FILE_EXT = '\\.(?:json5?|jsonl|jsx?|mdx?|py[cw]?|sh|tsx?)(?![a-z0-9])(?::\\d+)*';
+const FILE_NAME = new RegExp(`${FILE_EXT}$`, 'i');
+const FILE_NAMES = new RegExp(`\\S+${FILE_EXT}`, 'gi');
+const FILE_MARK = '\u0003';
+const MARKED_FILES = new RegExp(`${FILE_MARK}(?::\\d+)*`, 'g');
+
+function setAside(text) {
+  const words = [];
+  let masked = '';
+  let last = 0;
+  for (const { start, end } of slashWords(text)) {
+    const word = text.slice(start, end);
+    const file = word.includes('://') ? null : FILE_NAME.exec(word);
+    masked += text.slice(last, start);
+    if (file) {
+      // The line numbers stay out of the mark: a colon after plumbing is where the detail starts.
+      masked += FILE_MARK;
+      last = end - /(?::\d+)*$/.exec(file[0])[0].length;
+    } else {
+      masked += `\u0001${words.length}\u0002`;
+      words.push(word);
+      last = end;
+    }
+  }
+  return { masked: masked + text.slice(last), words };
 }
 
 function operatorTitle(value, max = 140) {
-  const raw = inlineText(value, '');
+  const clean = inlineText(value, '').replace(/[\u0001-\u0003]/g, ' ');
+  const { masked: raw, words } = setAside(clean);
   const plumbing = /`|(?:^|\s)(?:node|npm|git|rg|grep)\s+|\S+\.(?:js|md|json|ts|py|sh)(?::\d+)?|\b[A-Z]{2,5}-\d+\b|\bpr\s*#?\s*\d+\b/i;
-  const source = plumbing.test(raw) && raw.includes(':') ? raw.split(':')[0] : raw;
+  // Plumbing anywhere makes what follows a colon detail, in a link or a path too; but a colon
+  // inside a link or a path is not that colon.
+  const source = plumbing.test(clean) && raw.includes(':') ? raw.split(':')[0] : raw;
   const scrubbed = source
     .replace(/`[^`]*`/g, ' ')
     .replace(/\b(?:done|check|verify|proof):\s+.*$/i, ' ')
-    .replace(/\b(?:node|npm|git|rg|grep)\s+[^\.;,]+/gi, ' ')
-    .replace(/\S+\.(?:js|md|json|ts|py|sh)(?::\d+)?/gi, ' ')
+    .replace(/\b(?:node|npm|git|rg|grep)\s+(?:[^.;,]|\.(?=\S))+/gi, ' ')
+    .replace(MARKED_FILES, ' ')
+    .replace(FILE_NAMES, ' ')
     .replace(/\b[A-Z]{2,5}-\d+\b/g, ' ')
     .replace(/\bpr\s*#?\s*\d+\b/gi, ' ')
     .replace(/\s+/g, ' ')
     .replace(/\([^a-z0-9]*\)/gi, ' ')
-    .replace(/,\s*,+/g, ',')
+    .replace(/,(?:\s*,)+/g, ',')
     .replace(/\s+([,.;:])/g, '$1')
     .replace(/([:(])\s*([,.;:)]|$)/g, '')
     .replace(/\s+\)/g, ')')
-    .trim();
-  return finishText(scrubbed || value, max);
+    .replace(/\(\s+/g, '(')
+    .trim()
+    .replace(/\u0001(\d+)\u0002/g, (_, index) => words[Number(index)]);
+  const short = finishText(scrubbed || value, max);
+  // A title that is one link too long to show whole leaves nothing: say so, do not print a blank.
+  return short || (clean ? 'untitled' : '');
 }
 
 function taskId(task) {
@@ -135,16 +206,30 @@ function needsHumanTag(task) {
   return taskTags(task).find((tag) => NEEDS_HUMAN_TAGS.has(tag)) || null;
 }
 
+// A pointer is printed like any other link, so it is cleaned like one (see
+// printableLink in lib/owner-brief.js): a link loses its login, query string, and
+// fragment, and one that carries a secret is not a pointer at all, so the next kind
+// is tried. A file path that the redactor would change is passed over the same way.
+// A link that could not be printed is gone, all of it: the other kinds are read from the
+// words around it, cleaned, and never from a piece of it (the pr123 in token=pr123 is
+// part of the secret, not a pull request). A proof can be as long as someone makes it, so
+// only the first part is read, cut at a space (cutAtSpace), and the patterns here take
+// each character once: a run is looked at from its first character only, never again
+// from every character inside it.
 function extractPointer(text) {
-  const value = inlineText(text, '');
+  const value = inlineText(cutAtSpace(text), '');
   if (!value) return '';
   const url = value.match(/https?:\/\/[^\s<>"')]+/i);
-  if (url) return url[0].replace(/[.,;]+$/, '');
-  const pathMatch = value.match(/(?:^|\s)((?:\.atris|atris)\/[^\s,;:)]+)/i);
-  if (pathMatch) return pathMatch[1].replace(/[.,;]+$/, '');
-  const pr = value.match(/\bpr\s*#?\s*\d+\b/i);
+  const link = url ? printableLink(url[0].replace(/(?<![.,;])[.,;]+$/, '')) : null;
+  if (link) return link;
+  const around = value.replace(/(?<![a-z0-9+.-])[a-z0-9+.-]*:\/\/\S*/gi, ' ');
+  const pathMatch = around.match(/(?:^|\s)((?:\.atris|atris)\/[^\s,;:)]+)/i);
+  const file = pathMatch ? pathMatch[1].replace(/(?<![.,;])[.,;]+$/, '') : '';
+  if (file && redacted(file) === file) return file;
+  const words = redacted(around);
+  const pr = words.match(/\bpr\s*#?\s*\d+\b/i);
   if (pr) return pr[0].replace(/\s+/g, ' ');
-  return /\b(pass(?:ed)?|verified|green|merged|ok)\b/i.test(value) ? 'proof on file' : '';
+  return /\b(pass(?:ed)?|verified|green|merged|ok)\b/i.test(words) ? 'proof on file' : '';
 }
 
 function proofPointer(task) {
@@ -183,15 +268,34 @@ function formatAge(start, nowMs) {
   return `${Math.floor(hours / 24)}d`;
 }
 
-function waitingReason(task) {
+// Why a job is on the waiting list: someone marked its review, it sits in a
+// protected lane, it is tagged for a person, or it is plain review.
+function waitingKind(task) {
   const approval = String(task.review?.approval_status || task.metadata?.approval_status || '').toLowerCase();
-  if (approval && approval !== 'pending') return `review lane is ${approval}`;
+  if (approval && approval !== 'pending') return { kind: 'approval', approval };
   const denied = deniedTagForTask(task);
-  if (denied) return `protected ${denied} lane`;
-  if (needsHumanTag(task)) return 'needs human lane';
+  if (denied) return { kind: 'protected', lane: denied };
+  if (needsHumanTag(task)) return { kind: 'human' };
+  return { kind: 'review' };
+}
+
+function waitingReason(task) {
+  const why = waitingKind(task);
+  if (why.kind === 'approval') return `review lane is ${why.approval}`;
+  if (why.kind === 'protected') return `protected ${why.lane} lane`;
+  if (why.kind === 'human') return 'needs human lane';
   return 'review lane';
 }
 
+// The same reasons, said the way the owner's screen says them.
+function plainWaitingWhy(task) {
+  const why = waitingKind(task);
+  if (why.kind === 'approval') return `Waiting in review, marked ${why.approval}.`;
+  if (why.kind === 'protected') return `Protected ${why.lane} work, so only you can approve it.`;
+  if (why.kind === 'human') return 'Marked as needing a person.';
+  return 'Finished and waiting for your review.';
+}
+
 function isWaitingTask(task) {
   const status = String(task.status || '').toLowerCase();
   if (status === 'done' || status === 'failed' || status === 'cancelled') return false;
@@ -209,36 +313,56 @@ function buildLanded(tasks, cutoffMs, nowMs) {
     .sort((a, b) => b.doneMs - a.doneMs)
     .map(({ task, doneMs }) => ({
       id: taskId(task),
-      title: inlineText(task.title, 'done task'),
+      title: inlineText(redacted(task.title), 'done task'),
       proof: proofPointer(task),
       age: formatAge(doneMs, nowMs),
     }));
 }
 
-function buildWaiting(tasks, nowMs) {
+// Waiting jobs, longest waiting first, each with its task and when it started
+// waiting so the owner's screen can order them its own way.
+function waitingEntries(tasks, nowMs) {
   return tasks
     .filter(isWaitingTask)
     .map((task) => {
       const startMs = taskTime(task, ['metadata.agent_certified_at', 'updated_at', 'created_at']);
       return {
-        id: taskId(task),
-        title: inlineText(task.title, 'review task'),
-        why: waitingReason(task),
-        age: formatAge(startMs, nowMs),
-        _sort: startMs || 0,
+        task,
+        since: startMs || 0,
+        item: {
+          id: taskId(task),
+          title: inlineText(redacted(task.title), 'review task'),
+          why: waitingReason(task),
+          age: formatAge(startMs, nowMs),
+        },
       };
     })
-    .sort((a, b) => a._sort - b._sort)
-    .map(({ _sort, ...item }) => item);
+    .sort((a, b) => a.since - b.since);
+}
+
+// What brief has always shown as waiting on you, as items on the owner's screen.
+// A closed (archived) job keeps its place in the older list but nobody waits on it.
+function decisionItems(entries) {
+  return entries
+    .filter(({ task }) => String(task.status || '').toLowerCase() !== 'archived')
+    .map(({ task, since, item }) => ({
+      task_id: typeof task.id === 'string' && task.id ? task.id : null,
+      accept_id: item.id,
+      title: task.title,
+      why: plainWaitingWhy(task),
+      since,
+    }));
 }
 
+// A move names a job in flight and whoever holds it, so its words are cleaned like any
+// other title or name (see redacted in lib/owner-brief.js).
 function buildMoves(root) {
   return nextMoves(root, 3).map((move) => ({
     id: move.id,
-    title: inlineText(move.title, 'next move'),
-    why: inlineText(move.why || move.source || 'workspace signal', 'workspace signal'),
+    title: inlineText(redacted(move.title), 'next move'),
+    why: inlineText(redacted(move.why || move.source), 'workspace signal'),
     source: move.source || null,
-    owner: move.owner || move.member || null,
+    owner: redacted(move.owner || move.member) || null,
   }));
 }
 
@@ -247,26 +371,47 @@ function buildWeekLine(root, nowMs) {
   return renderWeekReport(data).split(/\r?\n/)[0] || 'week in review: 0 landed, 0 completions, 0 xp';
 }
 
-function buildBriefData(root = process.cwd(), { days = 1, now = Date.now() } = {}) {
+// `owner` adds the owner's screen: needs_you, done_this_week, and team, read from the
+// task store (see lib/owner-brief.js). The command asks for it; a caller that only
+// wants the older lists (atris activate) gets exactly those and never opens the store.
+function buildBriefData(root = process.cwd(), { days = 1, now = Date.now(), owner = false } = {}) {
   const windowDays = Number.isFinite(Number(days)) && Number(days) > 0 ? Math.floor(Number(days)) : 1;
   const nowMs = normalizeNow(now);
   const cutoffMs = nowMs - windowDays * DAY_MS;
   const tasks = readProjection(root);
-  return {
+  const entries = waitingEntries(tasks, nowMs);
+  const data = {
     schema: 'atris.brief.v1',
     days: windowDays,
     landed: buildLanded(tasks, cutoffMs, nowMs),
-    waiting: buildWaiting(tasks, nowMs),
+    waiting: entries.map((entry) => entry.item),
     moves: buildMoves(root),
     week: buildWeekLine(root, nowMs),
   };
+  if (!owner) return data;
+  const { error, ...screen } = buildOwnerBrief(root, { now: nowMs, decisions: decisionItems(entries) });
+  return { ...data, ...screen, ...(error ? { owner_error: error } : {}) };
 }
 
 function plural(count, word, pluralWord = `${word}s`) {
   return `${count} ${count === 1 ? word : pluralWord}`;
 }
 
+// The json carries each title as the cleaner leaves it: up to 300 characters, cut at a whole word. A
+// person reads it short, on one line, with the plumbing left out (operatorTitle), so the screen, the
+// page, and the text sent are made from this copy.
+function withShortTitles(data) {
+  const short = (item) => ({ ...item, title: operatorTitle(item && item.title, OWNER_TITLE_MAX) || 'untitled' });
+  return {
+    ...data,
+    needs_you: data.needs_you.map(short),
+    done_this_week: Array.isArray(data.done_this_week) ? data.done_this_week.map(short) : data.done_this_week,
+  };
+}
+
 function renderBrief(data) {
+  // The owner's screen when the data has it, the older one-line-per-thing brief otherwise.
+  if (Array.isArray(data?.needs_you)) return renderOwnerText(withShortTitles(data));
   const landed = Array.isArray(data?.landed) ? data.landed : [];
   const waiting = Array.isArray(data?.waiting) ? data.waiting : [];
   const moves = Array.isArray(data?.moves) ? data.moves : [];
@@ -324,7 +469,23 @@ function panelRows(items, emptyTitle, emptySub, valueLabel) {
   }));
 }
 
+function renderOwnerHtml(data) {
+  const needs = data.needs_you.length;
+  const done = Array.isArray(data.done_this_week) ? data.done_this_week.length : 0;
+  const shown = withShortTitles(data);
+  return renderHtml({
+    theme: 'atris',
+    brand: { name: 'atris', accent: ' brief' },
+    blocks: [
+      { type: 'title', headline: 'atris brief', sub: `${needs} ${needs === 1 ? 'thing needs' : 'things need'} you, ${done} landed this week` },
+      ...ownerBlocks(shown),
+      { type: 'close', tagline: 'Read from your task list. Nothing here was changed.' },
+    ],
+  }, { title: 'atris brief' });
+}
+
 function renderBriefHtml(data) {
+  if (Array.isArray(data?.needs_you)) return renderOwnerHtml(data);
   const landed = Array.isArray(data?.landed) ? data.landed : [];
   const waiting = Array.isArray(data?.waiting) ? data.waiting : [];
   const moves = Array.isArray(data?.moves) ? data.moves : [];
@@ -397,7 +558,8 @@ function showHelp() {
   console.log('       atris brief log --engine <engine> --prompt-file <file> [--json|--raw]');
   console.log('       atris brief outcome <brief_id> --result pass|fail|partial --note <text> [--json|--raw]');
   console.log('       atris brief review [--lessons] [--json] [--limit N]');
-  console.log('Shows what landed, what waits on you, and what the loop should do next.');
+  console.log('One screen: what needs you, what got done this week, and how the team is doing.');
+  console.log('Read only. It never changes your jobs. --days N sets the older landed list in --json.');
 }
 
 function isBriefLedgerSubcommand(value) {
@@ -519,9 +681,12 @@ function runBriefLedgerCommand(args, root) {
   return 2;
 }
 
+// On the owner's screen only an item with an accept id can be accepted from the
+// prompt. Pull requests are merged on GitHub, so a screen of those has nothing to ask.
 function shouldPromptBrief({ flags, stdin = process.stdin, stdout = process.stdout, data }) {
   if (flags?.noInput) return false;
   if (!stdin?.isTTY || !stdout?.isTTY) return false;
+  if (Array.isArray(data?.needs_you)) return data.needs_you.slice(0, SHOWN).some((item) => item.accept_id);
   return Boolean((data?.waiting || []).length || (data?.moves || []).length);
 }
 
@@ -552,11 +717,26 @@ function parsePromptAnswer(answer) {
   return { action: 'invalid' };
 }
 
+// "a 2" on the owner's screen means the second item printed there, which is not
+// the second item of the older waiting list.
+function acceptFromScreen(data, index, acceptTask) {
+  const item = index >= 0 && index < SHOWN ? data.needs_you[index] : null;
+  if (!item) return { ok: false, message: 'no item with that number on this screen' };
+  if (!item.accept_id) {
+    return { ok: false, message: `item ${index + 1} cannot be accepted from here. if it has a pull request, merge that on GitHub. otherwise look at the job yourself.` };
+  }
+  const result = acceptTask(item.accept_id);
+  return { ok: result.ok, message: result.output || (result.ok ? `accepted ${item.accept_id}` : `could not accept ${item.accept_id}`) };
+}
+
 function handleBriefAnswer(root, data, answer, deps = {}) {
   const parsed = parsePromptAnswer(answer);
   const acceptTask = deps.acceptTask || ((id) => runTaskAccept(root, id));
   const moveApproval = deps.approveMove || ((move) => approveMove(root, move, deps.stamp));
+  const owner = Array.isArray(data?.needs_you);
   if (parsed.action === 'skip') return { ok: true, skipped: true, message: 'skipped' };
+  if (parsed.action === 'accept' && owner) return acceptFromScreen(data, parsed.index, acceptTask);
+  if (parsed.action === 'move' && owner) return { ok: false, message: 'next moves are not on this screen' };
   if (parsed.action === 'accept') {
     const item = (data.waiting || [])[parsed.index];
     if (!item) return { ok: false, message: 'no waiting item for that number' };
@@ -578,7 +758,10 @@ async function promptBrief(root, data, io = {}) {
   const output = io.stdout || process.stdout;
   const answer = await new Promise((resolve) => {
     const rl = readline.createInterface({ input, output });
-    rl.question('a N accept waiting, m N approve move, or enter to skip: ', (value) => {
+    const question = Array.isArray(data?.needs_you)
+      ? 'a N accept an item, or enter to skip: '
+      : 'a N accept waiting, m N approve move, or enter to skip: ';
+    rl.question(question, (value) => {
       rl.close();
       resolve(value);
     });
@@ -613,7 +796,7 @@ async function briefCommand(args = [], root = process.cwd(), io = {}) {
     return 0;
   }
 
-  const data = buildBriefData(root, { days: flags.days });
+  const data = buildBriefData(root, { days: flags.days, owner: true });
   if (flags.json) {
     console.log(JSON.stringify(data, null, 2));
     return 0;

package/commands/engine.js

@@ -2294,10 +2294,13 @@ function parseDispatchArgs(args) {
   let base = '';
   let json = false;
   let yolo = false;
+  let pick = '';
   for (let i = 0; i < args.length; i += 1) {
     const a = args[i];
     if (a === '--engine') { engine = args[i + 1] || ''; i += 1; continue; }
     if (a.startsWith('--engine=')) { engine = a.slice('--engine='.length); continue; }
+    if (a === '--pick') { pick = args[i + 1] || ''; i += 1; continue; }
+    if (a.startsWith('--pick=')) { pick = a.slice('--pick='.length); continue; }
     if (a === '--prompt-file') { promptFile = args[i + 1] || ''; i += 1; continue; }
     if (a.startsWith('--prompt-file=')) { promptFile = a.slice('--prompt-file='.length); continue; }
     if (a === '--base') { base = args[i + 1] || ''; i += 1; continue; }
@@ -2307,13 +2310,19 @@ function parseDispatchArgs(args) {
     if (a.startsWith('--')) continue;
     taskIds.push(a);
   }
-  return { taskIds, engine, promptFile, base, json, yolo };
+  return { taskIds, engine, promptFile, base, json, yolo, pick };
 }
 
 function runDispatchCommand(args, root) {
-  const { taskIds, engine, promptFile, base, json, yolo } = parseDispatchArgs(args);
+  const { taskIds, engine, promptFile, base, json, yolo, pick } = parseDispatchArgs(args);
   if (!taskIds.length || !engine) {
-    console.error('usage: atris engine dispatch <task-id> [<task-id> ...] --engine <engine> [--prompt-file <f>] [--yolo]');
+    console.error('usage: atris engine dispatch <task-id> [<task-id> ...] --engine <engine> [--prompt-file <f>] [--yolo] [--pick rating|turns]');
+    return 2;
+  }
+  // --pick rating|turns: what to do when the engine named here dies or stalls. rating (the default) hands the
+  // job to the builder its results favor, turns keeps the old rule.
+  if (args.some((arg) => arg === '--pick' || String(arg).startsWith('--pick=')) && !require('../lib/builder-pick').parsePickFlag(pick)) {
+    console.error('engine dispatch: --pick takes rating or turns');
     return 2;
   }
   const canonical = canonicalEngineName(engine);
@@ -2359,6 +2368,7 @@ function runDispatchCommand(args, root) {
     engine: canonical,
     prompt: promptOverride,
     yolo,
+    ...(pick ? { pick } : {}),
     ...(base ? { checkoutBase: base } : {}),
     ...(pin.roster_model ? { model: pin.roster_model } : {}),
     ...(pin.roster_effort ? { effort: pin.roster_effort } : {}),
@@ -2623,7 +2633,7 @@ function engineCommand(args = [], deps = {}) {
     if (sub === 'help' || args.includes('--help') || args.includes('-h')) {
       console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
       console.log('\n  long read-only asks: atris engine ask "..." --engine agy --timeout <seconds>\n                           quick asks default to 120 seconds; explicit jobs allow up to 3600\n                           follow live work with atris engine watch latest');
-      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n                           flags a model with a newer version on this machine, or a pin not proven in 30 days\n                           (a landed run, or "verified 2026-09-30" on its line, proves it)\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine roster set <job> <tool> <model>\n                           swap the lead of a job to a tool and model this machine offers; the old lead becomes the first backup\n  atris engine roster set --member <name> <tool> <model>\n                           give one member its own model; every other job stays put\n  atris engine roster --runs [job]\n                           the last 20 runs, newest first, with tool, model, time, and outcome\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--prep <job>] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --promote "<tool> [model]" | --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --promote moves one of its workers to the top as written;\n                           --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --prep search has that job read the task first and hand this worker a short brief;\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job;\n                           notes always answers: its roster pick, else agy then haiku\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine sweep [--apply] [--json]\n                           list ssh-agents that engine shells left running; --apply rechecks and stops them\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n                           flags a model with a newer version on this machine, or a pin not proven in 30 days\n                           (a landed run, or "verified 2026-09-30" on its line, proves it)\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine roster set <job> <tool> <model>\n                           swap the lead of a job to a tool and model this machine offers; the old lead becomes the first backup\n  atris engine roster set --member <name> <tool> <model>\n                           give one member its own model; every other job stays put\n  atris engine roster --runs [job]\n                           the last 20 runs, newest first, with tool, model, time, and outcome\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--prep <job>] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --promote "<tool> [model]" | --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --promote moves one of its workers to the top as written;\n                           --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --prep search has that job read the task first and hand this worker a short brief;\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job;\n                           notes always answers: its roster pick, else agy then haiku\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine sweep [--apply] [--json]\n                           list ssh-agents that engine shells left running; --apply rechecks and stops them\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo] [--pick rating|turns]\n                           one-command claim, worktree, build, verify, ship, ready; if the engine dies or stalls, the job goes to the builder its results favor (--pick turns keeps the old rule)\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
       return 0;
     }
     if (isFreshWorkspace(root)) {

package/commands/mission.js

@@ -758,6 +758,7 @@ function printJsonOrText(payload, lines, asJson) {
 
 const MISSION_RUN_VALUE_FLAGS = [
   '--slots',
+  '--pick',
   '--max-ticks',
   '--max-idle-ticks',
   '--max-wall',
@@ -10256,14 +10257,34 @@ async function parseAndValidateMissionRunPhase(args) {
   // safe-lane tasks, build in parallel worktrees, land serially. Humble flag,
   // full loop, see lib/fleet.js. --dry-run previews the staffing only.
   if (hasFlag(args, '--fleet')) {
-    const { runFleetFlight, flightExitCode } = require('../lib/fleet');
+    const { runFleetFlight, flightExitCode, FLEET_CAPABLE } = require('../lib/fleet');
+    const { parsePickFlag } = require('../lib/builder-pick');
     const slots = Math.max(1, Number(readFlag(args, '--slots', '')) || 3);
+    // --pick rating|turns: rating (the default) deals each job to the builder its results favor, turns deals
+    // in turn as the fleet always did. --engine <name> sends every job to that engine and skips the picker.
+    const pickFlag = readFlag(args, '--pick', '');
+    if ((pickFlag || args.some((arg) => arg === '--pick' || String(arg).startsWith('--pick='))) && !parsePickFlag(pickFlag)) {
+      exitMissionError('--pick takes rating or turns', 2, asJson);
+    }
+    const engineFlag = readFlag(args, '--engine', '').toLowerCase();
+    if (engineFlag && !FLEET_CAPABLE.includes(engineFlag)) {
+      exitMissionError(`--engine for a fleet takes one of ${FLEET_CAPABLE.join(', ')}`, 2, asJson);
+    }
+    if (engineFlag && !hasFlag(args, '--dry-run')) {
+      try {
+        require('../lib/engine-registry').requireEngineBin(engineFlag);
+      } catch (err) {
+        exitMissionError(err.message, 2, asJson);
+      }
+    }
     // Default: cut build worktrees from origin/master (checkoutBase). --base
     // keeps launcher-HEAD only when the operator asks for it explicitly.
     const baseOverride = readFlag(args, '--base', '');
     const flight = await runFleetFlight({
       slots,
       dryRun: hasFlag(args, '--dry-run'),
+      pick: pickFlag,
+      ...(engineFlag ? { engine: engineFlag } : {}),
       log: asJson ? () => {} : console.log,
       ...(baseOverride ? { checkoutBase: baseOverride } : {}),
     });
@@ -12485,7 +12506,7 @@ atris mission - durable goal + loop + owner + proof state
   atris mission set-verifier <id> "<cmd>" [--json]
   atris mission route set <id> [--file <route.json>|--file -] [--json]   Validate and save a falsifiable route from a JSON file or stdin
   atris mission "<objective>" [--owner <member>]   Shortcut for: atris mission run "<objective>"
-  atris mission run --fleet [--slots 3] [--dry-run] [--json]   Staff every idle capable engine on claimable safe-lane tasks: parallel worktree builds, serial rebase-before-ship landings, receipt in atris/runs/
+  atris mission run --fleet [--slots 3] [--dry-run] [--json] [--pick rating|turns] [--engine <name>]   Staff every idle capable engine on claimable safe-lane tasks: parallel worktree builds, serial rebase-before-ship landings, receipt in atris/runs/. Each job goes to the builder its real results favor (--pick turns deals in turn; --engine sends every job to one engine)
   atris mission run "<objective>" --cloud [--lane fast|pro|max] [--agent <id>]   Enqueue on the Atris backend instead of running local ticks
   atris mission run ["objective"|<member> ["objective"]|id|--due] [--owner <member>] [--budget quick|long|deep] [--max-ticks 4] [--max-wall 3600] [--cadence "15m"] [--detach] [--land --repo <path> --verify "git diff --check"]
                                 [--native-goal-status active|paused|usageLimited] [--native-goal-objective "..."] [--manual-ack] [--allow-native-goal-supersede] [--take-goal-slot]

package/commands/rating.js

@@ -8,6 +8,7 @@
 const { hasFlag } = require('../lib/arg-parser');
 const { modelLabel } = require('../lib/roster-models');
 const rating = require('../lib/atris-rating');
+const { steeringSummary } = require('../lib/builder-pick');
 
 const USAGE = [
   'usage: atris rating [engine | member] [--json]',
@@ -44,7 +45,7 @@ function readHere(deps = {}) {
     return null;
   }
   if (!played || played.error || played.no_history) return null;
-  const { rosterRows, tally } = require('../lib/gm-season');
+  const { rosterRows, tally, missReasons } = require('../lib/gm-season');
   // Jobs still in review whose pull request is open, per builder. These do not depend on the
   // last 30 days of plays: a job can wait longer than that, and its builder still has it.
   const waiting = new Map();
@@ -65,14 +66,7 @@ function readHere(deps = {}) {
   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);
+    const miss_reasons = missReasons(played.outcomes || [], row.name);
     return { member: row.name, ovr: row.ovr, landed: row.landed, finished: row.finished, ...(row.not_needed ? { not_needed: row.not_needed } : {}), ...(row.held ? { held: row.held } : {}), ...(row.could_not_start ? { could_not_start: row.could_not_start } : {}), ...(waiting.has(row.name) ? { waiting_on_pull_request: waiting.get(row.name) } : {}), 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);
@@ -179,16 +173,19 @@ function ratingCommand(args = [], deps = {}) {
     return 1;
   }
   const here = readHere(deps);
+  // Steering: the fleet picks each job's builder from the results above. The line shows only while that is on.
+  const steering = steeringSummary({ root: deps.root || taskDb.workspaceRoot(process.cwd()), env: deps.env || process.env });
   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,
+      steering,
     }, null, 2)}\n`);
     return 0;
   }
-  write(`${rating.renderCombine(cards)}${here ? `\n\n${renderHere(here)}` : ''}\n`);
+  write(`${rating.renderCombine(cards)}${here ? `\n\n${renderHere(here)}` : ''}${steering.on ? `\n\n${steering.line}` : ''}\n`);
   return 0;
 }