atris 3.76.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,7 +44,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 +65,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);

package/lib/gm-season.js

@@ -89,6 +89,20 @@ function memberRatings(outcomes = []) {
   return new Map([...groups].map(([name, list]) => [name, { ovr: ovr(list), finished: tally(list).finished }]));
 }
 
+// The words a member's misses came with, most often given first: the reason on
+// its dropped, sent back, and abandoned plays. atris rating and the owner brief
+// both show these, so both read them here.
+function missReasons(outcomes, member, limit = 3) {
+  const reasons = new Map();
+  for (const play of outcomes || []) {
+    if (play.member === member && ['dropped', 'sent_back', 'abandoned'].includes(play.kind) && play.reason) {
+      reasons.set(play.reason, (reasons.get(play.reason) || 0) + 1);
+    }
+  }
+  return [...reasons].map(([reason, count]) => ({ reason, count }))
+    .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason)).slice(0, limit);
+}
+
 // Last n finished jobs, oldest on the left, newest on the right.
 function form(outcomes, n = 5) {
   return [...(outcomes || [])]
@@ -610,6 +624,65 @@ function playEventsSql(extraWhere = '') {
      ORDER BY e.created_at ASC`;
 }
 
+// A workspace's plays as they stood at an earlier time: the same plays loadSeason
+// would have found on that day, from the events that existed by then and nothing
+// after. Working out all of the history and cutting the plays by date afterwards is
+// not the same thing. A landing that came later replaces an earlier miss, and a
+// later "not needed" note clears one, so the miss would be gone from a rating that
+// was printed with it. Every other fact a play is built from (the claim before it,
+// whether the engine had started) is an earlier event in the same job, so cutting
+// the events is enough.
+//
+// The job's own row is the one thing that is not an earlier event. It says who holds
+// the job now, and today's rating falls back on that when a play has no claim on
+// record before it. For a day in the past that is the wrong answer: a job nobody held
+// that day would be handed to whoever took it later, and sent back to them. So the
+// holder and the claim time are cleared here. A play with no claim on record at or
+// before the day has no member and is not counted, the way a job nobody held was not
+// counted on that day. (Only the title is still read from the row, and it is only
+// shown.) `db` is an open task store.
+function outcomesAsOf(db, workspaceRoot, asOf, days = SEASON_DAYS) {
+  const since = asOf - days * DAY_MS;
+  const rows = db.prepare(playEventsSql('AND e.workspace_root = ? AND e.created_at <= ?')).all(since, workspaceRoot, asOf)
+    .map(row => ({ ...row, claimed_by: null, claimed_at: null }));
+  return outcomesFromEvents(rows, since).filter(play => play.at <= asOf);
+}
+
+// The jobs open right now whose latest release is one the rating reads as held (the
+// work is done and its pull request waits for a person, but the proof could not be
+// saved) or as could_not_start (the build machine never ran the job), and that nobody
+// has claimed or landed since, and that has not been archived or reopened since: a
+// release older than the job's latest archive or reopen is not what the job is waiting
+// on, because it was closed and then opened again for new work. There is no age limit:
+// loadSeason only looks back 30 days, and a job left open by a release older than that
+// is still where it was left.
+// Each release is read by the rating's own query and rules (the member, the kind, the
+// engine_started mark), so this cannot disagree with atris rating about what a release
+// was. Returns one play per job, in the shape outcomesFromEvents makes. `db` is an open
+// task store.
+function openReleasePlays(db, workspaceRoot) {
+  const found = db.prepare(`
+    SELECT r.event_id AS event_id, r.task_id AS task_id, r.version AS version
+      FROM task_events r
+      JOIN tasks t ON t.id = r.task_id
+     WHERE t.workspace_root = ? AND t.status = 'open' AND r.event_type = 'claim_released'
+       -- a first cut on the words, so only the few releases of these kinds are read in full below
+       AND (r.payload LIKE '%proof_not_saved%' OR r.payload LIKE '%could_not_start%')
+       AND r.version = (SELECT MAX(x.version) FROM task_events x WHERE x.task_id = r.task_id AND x.event_type = 'claim_released')
+       AND NOT EXISTS (SELECT 1 FROM task_events later WHERE later.task_id = r.task_id AND later.version > r.version AND later.event_type IN ('claimed', 'archived', 'reopened'))`)
+    .all(workspaceRoot);
+  const release = db.prepare(playEventsSql('AND e.event_id = ?'));
+  const after = db.prepare(playEventsSql('AND e.task_id = ? AND e.version > ?'));
+  const plays = [];
+  for (const { event_id: eventId, task_id: taskId, version } of found) {
+    const play = outcomesFromEvents(release.all(0, eventId)).find(made => made.event_id === eventId);
+    if (!play || (play.kind !== 'held' && play.kind !== 'could_not_start')) continue;
+    if (outcomesFromEvents(after.all(0, taskId, version)).some(made => made.kind === 'landed')) continue;
+    plays.push(play);
+  }
+  return plays;
+}
+
 // The one loader: last 30 days of plays for a workspace, plus open claims,
 // who is asleep, and what is up next. Opens the db read-only.
 // `lastSeen` pins the recap to a session's opening look; without it the
@@ -1282,11 +1355,15 @@ module.exports = {
   lastPlays,
   loadSeason,
   memberRatings,
+  missReasons,
+  openReleasePlays,
+  outcomesAsOf,
   outcomesFromEvents,
   ovr,
   ownerMood,
   readLastSeen,
   rosterRows,
+  SEASON_DAYS,
   seasonBoard,
   sinceLastLook,
   stillStuck,