atris 3.75.0 → 3.77.0

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/rating.js

@@ -44,26 +44,29 @@ function readHere(deps = {}) {
     return null;
   }
   if (!played || played.error || played.no_history) return null;
-  const { rosterRows } = 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();
+  for (const review of played.reviews || []) {
+    if (review && review.waiting_on_pull_request && review.member) waiting.set(review.member, (waiting.get(review.member) || 0) + 1);
+  }
+  const roster = rosterRows({ outcomes: played.outcomes || [], limit: Number.MAX_SAFE_INTEGER });
   // A member whose only misses were later confirmed not needed, or whose only jobs
   // wait on a pull request or could not start, has no finished job, but still shows,
   // so those jobs have somewhere to be counted.
-  const rows = rosterRows({ outcomes: played.outcomes || [], limit: Number.MAX_SAFE_INTEGER }).filter((row) => row.finished > 0 || row.not_needed > 0 || row.held > 0 || row.could_not_start > 0);
+  const rows = roster.filter((row) => row.finished > 0 || row.not_needed > 0 || row.held > 0 || row.could_not_start > 0 || waiting.has(row.name));
+  for (const name of waiting.keys()) {
+    if (!roster.some((row) => row.name === name)) rows.push({ name, ...tally([]), ovr: null });
+  }
   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, ...(row.not_needed ? { not_needed: row.not_needed } : {}), ...(row.held ? { held: row.held } : {}), ...(row.could_not_start ? { could_not_start: row.could_not_start } : {}), job: seat.job || null, model: seat.model || null, ...(miss_reasons.length ? { miss_reasons } : {}) };
+    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);
   const buildModel = buildJob && buildJob.now_runs ? buildJob.now_runs.model : null;
@@ -126,6 +129,10 @@ function renderMember(m, card) {
   if (m.not_needed) lines.push(`  not needed: ${m.not_needed} (confirmed by someone else, so ${m.not_needed === 1 ? 'it does' : 'they do'} not count either way)`);
   if (m.held) lines.push(`  waiting on a pull request: ${m.held} (the work is done and a person has to land it, so ${m.held === 1 ? 'it does' : 'they do'} not count either way)`);
   if (m.could_not_start) lines.push(`  ${couldNotStartLine(m.could_not_start)}`);
+  if (m.waiting_on_pull_request) {
+    const one = m.waiting_on_pull_request === 1;
+    lines.push(`  ${m.waiting_on_pull_request} ${one ? 'job waits' : 'jobs wait'} on an open pull request. Check GitHub and credit ${one ? 'it' : 'them'}: atris task sweep --held`);
+  }
   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:');

package/commands/task.js

@@ -210,6 +210,7 @@ atris task - durable local task state (SQLite, gitignored)
                                            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 sweep --held [--everywhere] [--dry-run] [--json]   Check held jobs against GitHub: credit a merge, release a closed pull request
   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
 
@@ -400,8 +401,10 @@ function failAgentProofOnly(label, detail) {
   );
 }
 
-function printJson(value) {
-  const buffer = Buffer.from(`${JSON.stringify(value, null, 2)}\n`, 'utf8');
+// Write straight to stdout and wait until it is all out, so a command that exits right after
+// printing (process.exit drops whatever a pipe still holds) never loses the end of its output.
+function writeStdoutSync(text) {
+  const buffer = Buffer.from(text, 'utf8');
   const retryWait = new Int32Array(new SharedArrayBuffer(4));
   let offset = 0;
   while (offset < buffer.length) {
@@ -417,6 +420,10 @@ function printJson(value) {
   }
 }
 
+function printJson(value) {
+  writeStdoutSync(`${JSON.stringify(value, null, 2)}\n`);
+}
+
 function refreshCareerXpProjection(workspaceRoot) {
   if (!workspaceRoot) return null;
   try {
@@ -9743,6 +9750,9 @@ function cmdReady(args) {
   const merge = readyMergeFlags(args);
   guardExplicitActor('atris task ready', flag(args, '--as'));
   const actor = String(flag(args, '--as') || DEFAULT_OWNER);
+  // The others who built the work with --as, by name, comma apart: a flight that ran for a member
+  // hands in under the member's name and names the engines that ran here. Only a hand-in uses it.
+  const builtWith = textFlag(args, ['--built-with']).split(',').map((name) => name.trim()).filter(Boolean);
   const resultFields = {
     changed: textFlag(args, ['--changed', '--done']),
     checked: textFlag(args, ['--checked', '--check', '--verified']),
@@ -9790,6 +9800,7 @@ function cmdReady(args) {
     landing,
     merge,
     result: resultSentence,
+    builtWith,
   });
   if (!result.ready) {
     console.error(`ready failed: ${result.reason}`);
@@ -10419,10 +10430,12 @@ function cmdCertifyVerified(args, options = {}) {
       results.push({ ref, action: 'skipped', reason: evaluation.reason });
       continue;
     }
-    // judge != worker: the re-run only counts as an independent check when
-    // its actor is not the builder of the row it is judging.
+    // judge != worker: the re-run only counts as an independent check when its actor never built
+    // the row it is judging: not its builder now, and not anyone who built it before (the store
+    // reads the whole history, so a job sent back, let go or reopened does not forget its builders).
     const builder = reviewIntegrity.taskBuilder(task);
-    if (builder && reviewIntegrity.normalizeActor(actor) === builder) {
+    const verifier = reviewIntegrity.normalizeActor(actor);
+    if (verifier && ((builder && verifier === builder) || taskDb.authorsOfTask(db, task).has(verifier))) {
       results.push({ ref, action: 'skipped', reason: 'verifier_is_builder' });
       continue;
     }
@@ -10906,7 +10919,61 @@ function evaluateSweepAutoAccept(task, root, includeProtected = false) {
   return { eligible: false, ref, reason: verifier.reason, evidence: verifier.evidence };
 }
 
+// atris task sweep --held: ask GitHub about each job waiting on an open pull request and write
+// down what happened (lib/held-pull-requests.js). Anyone may run it, agents included: GitHub is
+// the only source and the run grants nothing, so the agent block that guards --auto-accept does
+// not apply here. It takes none of the expired-claims flags.
+function cmdSweepHeld(args) {
+  for (const name of ['--auto-accept', '--stale-days', '--claimer']) {
+    if (hasFlag(args, name)) {
+      failTask('atris task sweep', 'held_flags_conflict', `atris task sweep: --held cannot be combined with ${name}`);
+    }
+  }
+  const named = flag(args, '--as');
+  if (named === true) failTask('atris task sweep', 'missing_actor', 'atris task sweep: --as needs a name');
+  guardExplicitActor('atris task sweep', named);
+  const actor = String(named || DEFAULT_OWNER);
+  const dryRun = hasFlag(args, '--dry-run');
+  const json = wantsJson(args);
+  const taskDb = getTaskDb();
+  const workspaceRoot = scopedWorkspaceRoot(taskDb, args);
+  const { sweepHeldJobs, describeHeldSweep } = require('../lib/held-pull-requests');
+
+  // A dry run only reads: it opens the task list read only and never creates one.
+  let db = null;
+  let reader = null;
+  if (!dryRun) {
+    db = taskDb.open();
+  } else if (fs.existsSync(taskDb.getDbPath())) {
+    const { DatabaseSync } = require('node:sqlite');
+    reader = new DatabaseSync(taskDb.getDbPath(), { readOnly: true });
+    db = reader;
+  }
+  let report;
+  try {
+    report = sweepHeldJobs(taskDb, db, { workspaceRoot, actor, dryRun });
+  } finally {
+    if (reader) reader.close();
+  }
+
+  const changed = report.summary.landed + report.summary.released > 0;
+  const projectionPath = changed ? writeDefaultProjection(taskDb, db).outPath : null;
+  if (json) printJson({ ...report, ...(projectionPath ? { projection_path: projectionPath } : {}) });
+  else writeStdoutSync(`${describeHeldSweep(report).join('\n')}\n`);
+  if (report.ok) return;
+
+  // GitHub could not be reached, so the rest were not asked and nothing more changed. Whatever
+  // was settled before that is still refreshed on the task list.
+  if (changed) autoRenderTodoFromDb();
+  if (!json) {
+    const left = report.summary.not_asked;
+    console.error(`stopped: ${report.outage.detail}${left ? `. ${left} held ${left === 1 ? 'job was' : 'jobs were'} not asked` : ''}`);
+  }
+  process.exit(1);
+}
+
 function cmdSweep(args) {
+  if (hasFlag(args, '--held')) return cmdSweepHeld(args);
   if (!hasFlag(args, '--auto-accept')) {
     const taskDb = getTaskDb();
     const staleRaw = flag(args, '--stale-days');