atris 3.74.27 → 3.74.28

package/lib/gm-season.js

@@ -11,6 +11,7 @@
 const fs = require('fs');
 const path = require('path');
 const { atrisRating } = require('./atris-rating');
+const { isProofNotSaved } = require('./release-kind');
 
 const HOUR_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * HOUR_MS;
@@ -21,14 +22,22 @@ const ACTIVE_MISSION_STATUSES = new Set(['running', 'ready']);
 const KEPT_ACTIONS = new Set(['accepted', 'merged']);
 const FINISHED = new Set(['landed', 'dropped', 'sent_back', 'abandoned']);
 const FORM_LETTER = { landed: 'k', dropped: 'd', sent_back: 'x', abandoned: 'a' };
-const PLAY_WORD = { took: 'took', landed: 'landed', dropped: 'dropped', sent_back: 'sent back', abandoned: 'abandoned' };
+const PLAY_WORD = { took: 'took', landed: 'landed', dropped: 'dropped', sent_back: 'sent back', abandoned: 'abandoned', not_needed: 'not needed', held: 'held' };
+// A person has this long after a drop to say the job did not need doing.
+const NOT_NEEDED_WINDOW_MS = 7 * DAY_MS;
 
 // An outcome is one play:
 // { event_id, task_id, member, title, kind, at, claimed_at, landed_by }
-// kind is took | landed | dropped | sent_back | abandoned. abandoned is a
-// claim that ended archived without landing; a job still in review is
-// pending and not counted. at and claimed_at are epoch ms; claimed_at may
-// be null. landed_by is autoland | you, only on landed.
+// kind is took | landed | dropped | sent_back | abandoned | not_needed | held.
+// abandoned is a claim that ended archived without landing; a job still in
+// review is pending and not counted. not_needed is a drop or abandon that
+// someone other than the member later confirmed the job never needed; it is
+// not finished, so it counts for and against nobody. held is a claim let go
+// because the work is done and its pull request waits for a person, but the
+// proof that says so could not be saved; the release says so in a field
+// (lib/release-kind.js), never in its words. It is not finished either, so it
+// is neither a landing nor a miss. at and claimed_at are epoch ms; claimed_at
+// may be null. landed_by is autoland | you, only on landed.
 
 function byTimeAsc(a, b) {
   return Number(a.at || 0) - Number(b.at || 0);
@@ -41,7 +50,7 @@ function isFinished(outcome) {
 // jobs = landed + dropped + sent back + abandoned in the window, the same
 // count the rating divides by. Jobs still in review are pending.
 function tally(outcomes) {
-  const out = { took: 0, landed: 0, dropped: 0, sent_back: 0, abandoned: 0 };
+  const out = { took: 0, landed: 0, dropped: 0, sent_back: 0, abandoned: 0, not_needed: 0, held: 0 };
   for (const o of outcomes || []) {
     if (Object.prototype.hasOwnProperty.call(out, o.kind)) out[o.kind] += 1;
   }
@@ -320,7 +329,9 @@ function outcomeFromEvent(row) {
     kind = 'took';
     member = row.actor || payload.claimed_by;
   } else if (row.event_type === 'claim_released') {
-    kind = 'dropped';
+    // A release that carries the proof-not-saved fields is work waiting on a person,
+    // not a drop. Only the fields say so: the same words with no fields stay a drop.
+    kind = isProofNotSaved(payload) ? 'held' : 'dropped';
     member = payload.previous_claimed_by || payload.released_by || row.actor;
   } else if (row.event_type === 'claim_expired') {
     kind = 'dropped';
@@ -372,6 +383,30 @@ function hasStructuredMerge(payload) {
   });
 }
 
+// A drop or abandon that someone other than the member later confirmed the job
+// never needed (`task archive --not-needed`) is not the member's miss, so it
+// stops counting for or against them. Only another actor can clear it, and
+// only within a week of the miss: a member cannot wave off its own drop. A
+// note from a fleet engine never counts, whatever name it was filed under: an
+// engine cannot void another engine's miss, or its own.
+function clearNotNeededMisses(plays, rows) {
+  const notices = rows.filter(row => row.event_type === 'not_needed');
+  if (!notices.length) return;
+  const { normalizeActor, isFleetEngineActor } = require('./review-integrity');
+  plays.forEach((play, i) => {
+    if (play.kind !== 'dropped' && play.kind !== 'abandoned') return;
+    const holder = normalizeActor(play.member);
+    const notice = notices.find(row => {
+      const by = normalizeActor(row.actor);
+      const lag = Number(row.created_at) - play.at;
+      return row.task_id === play.task_id && by && by !== holder && !isFleetEngineActor(by) && lag >= 0 && lag <= NOT_NEEDED_WINDOW_MS;
+    });
+    if (!notice) return;
+    const why = (parseJson(notice.payload) || {}).reason;
+    plays[i] = { ...play, kind: 'not_needed', reason: typeof why === 'string' && why.trim() || play.reason, confirmed_by: notice.actor };
+  });
+}
+
 function outcomesFromEvents(rows, since = -Infinity) {
   const ordered = [...(rows || [])].sort((a, b) => String(a.task_id).localeCompare(String(b.task_id)) ||
     (a.version != null && b.version != null ? Number(a.version) - Number(b.version) : Number(a.created_at) - Number(b.created_at)));
@@ -403,6 +438,7 @@ function outcomesFromEvents(rows, since = -Infinity) {
     }
     if (ended) closed.add(key);
   }
+  clearNotNeededMisses(plays, ordered);
   return plays.filter(play => play.at >= since).sort(byTimeAsc);
 }
 
@@ -535,7 +571,7 @@ function playEventsSql(extraWhere = '') {
          WHERE p.task_id = e.task_id AND p.event_type = 'claimed' AND p.version < e.version
          ORDER BY p.version DESC LIMIT 1)
      WHERE EXISTS (SELECT 1 FROM task_events recent WHERE recent.task_id = e.task_id AND recent.created_at >= ?)
-       AND e.event_type IN ('claimed', 'claim_released', 'claim_expired', 'proof_ready', 'landing', 'completed', 'revision_requested', 'reopened', 'archived')
+       AND e.event_type IN ('claimed', 'claim_released', 'claim_expired', 'proof_ready', 'landing', 'completed', 'revision_requested', 'reopened', 'archived', 'not_needed')
        ${extraWhere}
      ORDER BY e.created_at ASC`;
 }

package/lib/release-kind.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Why a claim was let go, as a field the rating can read without reading words.
+//
+// One kind exists. The work is done and its pull request is open for a person to
+// land, but the proof that says so could not be saved. The builder did its part,
+// so the release is neither a landing nor a drop. The kind and the pull request
+// ride on the release event as fields; the reason text is only for people, and
+// nothing ever parses it.
+//
+// A release says this by passing both fields. The task db refuses half of a
+// marker, and the rating reads a release as this kind only when both are there.
+
+const PROOF_NOT_SAVED = 'proof_not_saved';
+
+// True for a release event payload that carries the kind and an open pull
+// request it can point at. Anything less is an ordinary release.
+function isProofNotSaved(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) return false;
+  if (payload.kind !== PROOF_NOT_SAVED) return false;
+  const pr = payload.pull_request;
+  if (!pr || typeof pr !== 'object' || Array.isArray(pr)) return false;
+  if (String(pr.state || '').toLowerCase() !== 'open') return false;
+  return (Number.isInteger(pr.number) && pr.number > 0) || /^https?:\/\//i.test(String(pr.url || '').trim());
+}
+
+module.exports = { PROOF_NOT_SAVED, isProofNotSaved };

package/lib/review-integrity.js

@@ -25,6 +25,12 @@ function normalizeActor(value) {
     .replace(/^-+|-+$/g, '');
 }
 
+// The names the fleet claims and files proof under (fleet-codex, fleet-claude,
+// ...). An engine, not a person: its word can never confirm a job was not needed.
+function isFleetEngineActor(actor) {
+  return normalizeActor(actor).startsWith('fleet-');
+}
+
 // Builder identity, oldest signal wins: explicit stamp, then who claimed it,
 // then whoever sent the first proof.
 function taskBuilder(task) {
@@ -130,6 +136,7 @@ function validateActor(actor, { root } = {}) {
 
 module.exports = {
   normalizeActor,
+  isFleetEngineActor,
   taskBuilder,
   reviewEventActors,
   independentReviewActors,

package/lib/roster-runs.js

@@ -3,8 +3,9 @@
 // One line per run launched from a roster pick, so the owner can judge each
 // tool and model on real work instead of memory. A line says when, which job,
 // which member (if any), the engine, model, effort, time cap, seconds taken,
-// and how it ended: landed, failed, stalled, credit out, and who took over
-// when it was handed on. Tokens and cost appear only when the tool printed
+// and how it ended: landed, failed, stalled, credit out, held (built and
+// verified, with a pull request waiting for a person to land it), and who took
+// over when it was handed on. Tokens and cost appear only when the tool printed
 // them in output we already capture; nothing is guessed.
 //
 // Writing never throws into the run that called it, and reading only looks
@@ -21,7 +22,7 @@ const RUNS_FILE = path.join('.atris', 'state', 'roster_runs.jsonl');
 const ROTATED_NAME = /^roster_runs\.\d.*\.jsonl$/;
 const ROTATED_KEEP = 3;
 const ROTATED_READ = 2;
-const OUTCOMES = Object.freeze(['landed', 'failed', 'stalled', 'credit out', 'review unavailable']);
+const OUTCOMES = Object.freeze(['landed', 'failed', 'stalled', 'credit out', 'review unavailable', 'held']);
 const DEFAULT_DAYS = 7;
 const TAIL_BYTES = 512 * 1024;
 // Past this size the log is renamed aside before the append, never trimmed:
@@ -124,7 +125,7 @@ function parseRunUsage({ usage = null, cost_usd = null, stdout = '', stderr = ''
 // with --json. Writers that know the cause pass it as `detail`; this is the
 // fallback for a failed, stalled or credit-out run that has none. It is not
 // stored, so the log can still tell a real reason from the filler. A landed
-// run needs no reason.
+// run needs no reason. A held run is not a miss: it says what it waits for.
 function runReason(run) {
   if (!run || run.outcome === 'landed') return '';
   const given = clean(run.detail);
@@ -132,6 +133,7 @@ function runReason(run) {
   if (run.outcome === 'stalled') return 'it did not finish in time';
   if (run.outcome === 'credit out') return 'the engine hit its usage limit';
   if (run.outcome === 'review unavailable') return 'the second review was unavailable';
+  if (run.outcome === 'held') return 'waiting for a person to land it';
   return 'it failed and the tool gave no reason';
 }
 
@@ -326,7 +328,8 @@ function workerRuns(runs, { job, engine, model = '' } = {}) {
 }
 
 // "last 7 days: 9 runs, 7 landed, 1 stalled, 1 failed, median 11 min", or
-// null when there are no runs.
+// null when there are no runs. A held run counts as a run and as neither a
+// landing nor a miss.
 function summarizeRuns(runs, { days = DEFAULT_DAYS } = {}) {
   const list = runs || [];
   if (!list.length) return null;
@@ -343,6 +346,8 @@ function summarizeRuns(runs, { days = DEFAULT_DAYS } = {}) {
   };
   const reviewUnavailable = count('review unavailable');
   if (reviewUnavailable) summary.review_unavailable = reviewUnavailable;
+  const held = count('held');
+  if (held) summary.held = held;
   const tokens = list.map((run) => run.tokens).filter((value) => Number.isFinite(value));
   if (tokens.length) summary.tokens = tokens.reduce((sum, value) => sum + value, 0);
   const parts = [`${summary.runs} run${summary.runs === 1 ? '' : 's'}`];
@@ -350,6 +355,7 @@ function summarizeRuns(runs, { days = DEFAULT_DAYS } = {}) {
   if (summary.stalled) parts.push(`${summary.stalled} stalled`);
   if (summary.failed) parts.push(`${summary.failed} failed`);
   if (summary.review_unavailable) parts.push(`${summary.review_unavailable} review unavailable`);
+  if (summary.held) parts.push(`${summary.held} waiting for a person to land`);
   if (summary.credit_out) parts.push(`${summary.credit_out} credit out`);
   if (summary.median_seconds !== null) parts.push(`median ${durationText(summary.median_seconds)}`);
   summary.text = `last ${days} day${days === 1 ? '' : 's'}: ${parts.join(', ')}`;

package/lib/roster-suggest.js

@@ -23,10 +23,11 @@ const SUGGEST_MIN_GAP_POINTS = 25;
 const BOOT_TAIL_BYTES = 64 * 1024;
 
 // A credit wall says nothing about how well a worker does the job, and
-// engine health already benches it, so credit out runs are left out.
+// engine health already benches it, so credit out runs are left out. A held
+// run has not landed or failed yet: its pull request waits for a person.
 function judgedRuns(runs) {
   return runs
-    .filter((run) => run.outcome !== 'credit out' && run.outcome !== 'review unavailable')
+    .filter((run) => run.outcome !== 'credit out' && run.outcome !== 'review unavailable' && run.outcome !== 'held')
     .map((run, index) => ({ run, index }))
     .sort((a, b) => (Date.parse(b.run.at) - Date.parse(a.run.at)) || (b.index - a.index))
     .slice(0, SUGGEST_WINDOW_RUNS)

package/lib/roster-swap.js

@@ -261,7 +261,9 @@ function swapMember(root, memberName, engineWords, modelWords, options = {}) {
 // model this machine offers that can do the member's work, grouped by tool.
 // A model's last 7 days in the owner's words: the phone's swap card shows it
 // under the model, so it says finished, never the team's own word for it.
-const recordWords = seen => `${seen.landed} of ${seen.runs - (seen.review_unavailable || 0)} finished this week${seen.review_unavailable ? `, ${seen.review_unavailable} awaiting review` : ''}`;
+// A build whose pull request waits for the owner has not finished yet, so it is
+// said apart instead of counting for or against the model.
+const recordWords = seen => `${seen.landed} of ${seen.runs - (seen.review_unavailable || 0) - (seen.held || 0)} finished this week${seen.review_unavailable ? `, ${seen.review_unavailable} awaiting review` : ''}${seen.held ? `, ${seen.held} waiting for a person` : ''}`;
 
 // The current model is on top; models with a record in the last 7 days come
 // next, most landed first; the rest keep --available's order.

package/lib/router-brain.js

@@ -205,11 +205,12 @@ function readDispatchReceiptObservations(root) {
 // the router ranks because no roster line picks for them. Each run counts as
 // one receipt, the same weight and the same 30-day half-life as a task
 // receipt: landed is a pass; stalled and failed are a miss. Credit out is
-// left out, since engine health already benches that worker. The job name
-// maps to the role the router ranks by: build to executor, search to
-// navigator, review to validator, and an owner's job by its last word
-// ("small build" is build work). No record file means no observations, so
-// the ranking is exactly what it was without one.
+// left out, since engine health already benches that worker, and so is held,
+// a build whose pull request still waits for a person: not yet a pass or a
+// miss. The job name maps to the role the router ranks by: build to executor,
+// search to navigator, review to validator, and an owner's job by its last
+// word ("small build" is build work). No record file means no observations,
+// so the ranking is exactly what it was without one.
 const ROSTER_RUN_DAYS = 30;
 const ROSTER_JOB_ROLES = Object.freeze({ build: 'executor', search: 'navigator', review: 'validator' });
 
@@ -219,7 +220,7 @@ function readRosterRunObservations(root, now) {
   if (!fs.existsSync(file) && !rotatedRunsPaths(root).length) return [];
   const source = path.relative(root, file);
   return readRosterRuns(root, { days: ROSTER_RUN_DAYS, ...(now !== undefined ? { now } : {}) }).flatMap((run) => {
-    if (run.outcome === 'credit out' || run.outcome === 'review unavailable') return [];
+    if (run.outcome === 'credit out' || run.outcome === 'review unavailable' || run.outcome === 'held') return [];
     const words = String(run.job || '').trim().toLowerCase().split(/\s+/);
     const role = ROSTER_JOB_ROLES[words[words.length - 1]];
     const atMs = Date.parse(run.at);

package/lib/task-db.js

@@ -27,6 +27,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
 const reviewIntegrity = require('./review-integrity');
+const { PROOF_NOT_SAVED } = require('./release-kind');
 const dailyLog = require('./daily-log');
 const { isGenericScratchRoot } = require('./scratch-root');
 const { isDecisionTask } = require('./task-decision');
@@ -491,11 +492,26 @@ function linkedWorktreeRoots(ws) {
   return roots;
 }
 
+// The workspaces a workspace's task listing covers: the workspace itself and, for a main
+// checkout, the git worktrees linked to it.
+function workspaceViewRoots(ws) {
+  return ws ? [ws, ...linkedWorktreeRoots(ws)] : [];
+}
+
+// Whether a task row sits inside a workspace, by the rule listTasks applies when it is given
+// that workspace: the row's workspace_root is one of those roots, spelled exactly as stored
+// (workspaceRoot(cwd) gives that spelling). A row with no workspace_root is in the listing of no
+// workspace (only a listing of every workspace shows it), so it is inside none.
+function rowInWorkspace(row, ws) {
+  const rowRoot = row && typeof row.workspace_root === 'string' ? row.workspace_root : '';
+  return Boolean(rowRoot) && workspaceViewRoots(ws).includes(rowRoot);
+}
+
 function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
   const where = [];
   const args = [];
   if (ws) {
-    const roots = [ws, ...linkedWorktreeRoots(ws)];
+    const roots = workspaceViewRoots(ws);
     where.push(`workspace_root IN (${roots.map(() => '?').join(', ')})`);
     args.push(...roots);
   }
@@ -723,9 +739,28 @@ function sweepExpiredLeases() {
   }
 }
 
-function releaseTask(db, { id, actor, expectedUpdatedAt }) {
+// Why a claim was let go. The reason is for people: it is kept short and on one
+// line. A release that must not read as a drop (the work is done and its pull
+// request waits for a person, only the proof could not be saved) also carries a
+// kind and that pull request as fields, so the rating never has to read words.
+// Only the dispatch flight passes them, in its own process; `atris task release`
+// takes neither, so a worker cannot excuse its own miss with a flag. The two go
+// together or not at all; half a marker leaves the claim held.
+const RELEASE_REASON_MAX = 300;
+
+function releaseMarker(kind, pullRequest) {
+  const named = kind !== undefined && kind !== null && String(kind).trim() !== '';
+  if (!named && !pullRequest) return { marker: null };
+  const open = cleanOpenPullRequest(pullRequest);
+  if (!named || String(kind).trim() !== PROOF_NOT_SAVED || !open) return { invalid: true };
+  return { marker: { kind: PROOF_NOT_SAVED, pull_request: open } };
+}
+
+function releaseTask(db, { id, actor, expectedUpdatedAt, reason, kind, pullRequest }) {
   if (!id) throw new Error('id required');
   if (!actor) throw new Error('actor required');
+  const { marker, invalid } = releaseMarker(kind, pullRequest);
+  if (invalid) return { released: false, reason: 'invalid_release_marker' };
   const row = getTask(db, id);
   if (!row) return { released: false, reason: 'not_found' };
   if (row.status !== 'claimed') {
@@ -734,6 +769,7 @@ function releaseTask(db, { id, actor, expectedUpdatedAt }) {
   if (row.claimed_by !== actor) {
     return { released: false, reason: 'held_by_other', claimed_by: row.claimed_by || null };
   }
+  const releaseReason = compactEpisodeText(reason, RELEASE_REASON_MAX);
   const now = Date.now();
   const result = withBusyRetry(() => db.prepare(`
     UPDATE tasks
@@ -757,6 +793,8 @@ function releaseTask(db, { id, actor, expectedUpdatedAt }) {
     payload: {
       released_by: actor,
       previous_claimed_by: row.claimed_by || null,
+      ...(releaseReason ? { reason: releaseReason } : {}),
+      ...(marker || {}),
     },
   });
   return { released: true, row: updated, event };
@@ -804,6 +842,7 @@ function reopenTask(db, { id, actor, reason, metadata: metadataPatch, fromReview
     'latest_agent_lesson',
     'latest_agent_next_task',
     'latest_agent_proof',
+    'pull_request',
   ]) delete metadata[key];
 
   const result = withBusyRetry(() => db.prepare(`
@@ -967,6 +1006,31 @@ function archiveTask(db, { id, actor, reason, fromFailed = false, fromDone = fal
   return { archived: true, event, row: updated, logs };
 }
 
+// A person confirms that a job nobody finished did not need doing. The job is
+// archived the way `task archive` does it, and the call is written down as its
+// own event so the rating can stop counting the drop against the member. A job
+// that is already archived keeps its status; only the note is added.
+function archiveNotNeeded(db, { id, actor, reason, fromFailed = false } = {}) {
+  if (!id) throw new Error('id required');
+  const reasonText = String(reason || '').trim();
+  if (!reasonText) throw new Error('reason required');
+  const row = getTask(db, id);
+  if (!row) return { archived: false, recorded: false, reason: 'not_found' };
+  let archived = null;
+  if (row.status !== 'archived') {
+    archived = archiveTask(db, { id, actor, reason: reasonText, fromFailed });
+    if (!archived.archived) return { archived: false, recorded: false, reason: archived.reason };
+  }
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: row.workspace_root,
+    actor: actor || process.env.ATRIS_AGENT_ID || process.env.USER || null,
+    eventType: 'not_needed',
+    payload: { reason: reasonText, previous_status: row.status },
+  });
+  return { archived: Boolean(archived), recorded: true, event, row: archived ? archived.row : row };
+}
+
 // Marks metadata written by the 2026-06-10 "first-principles backlog reset"
 // (see atris/logs/2026/2026-06-10.md), a bulk pass that closed off-roadmap
 // tasks, including certified/proof-backed done work, by writing status
@@ -1060,6 +1124,18 @@ function cleanMergeRecord(merge) {
   return record;
 }
 
+// A pull request opened for a person to land. It names the PR and nothing
+// more: with no merge commit the rating still sees the job as waiting.
+function cleanOpenPullRequest(pr) {
+  if (!pr || typeof pr !== 'object' || pr.merge_commit || pr.merged_at) return null;
+  const record = { state: 'open' };
+  const number = Number(pr.number);
+  if (Number.isInteger(number) && number > 0) record.number = number;
+  const url = String(pr.url || '').trim();
+  if (/^https?:\/\//i.test(url)) record.url = url;
+  return record.number || record.url ? record : null;
+}
+
 function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, merge = null, resultTrace, result: resultSentence, reason, workRoot }) {
   if (!id) throw new Error('id required');
   const text = String(proof || '').trim();
@@ -1091,6 +1167,12 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, merge
   }
   const mergeRecord = cleanMergeRecord(merge);
   if (mergeRecord) metadata.merge_commit = mergeRecord.merge_commit;
+  const openPullRequest = mergeRecord ? null : cleanOpenPullRequest(merge);
+  // The row keeps the newest word on its pull request, so a reader that sees only
+  // the row (auto-accept, a compact list) can tell a job waiting on a person from
+  // one that landed. A review pass that names no pull request leaves it as it was.
+  if (mergeRecord) metadata.pull_request = { state: 'merged', ...mergeRecord };
+  else if (openPullRequest) metadata.pull_request = openPullRequest;
   // Only the builder's own ready names the work's commit. A reviewer or the
   // autoland verifier re-runs the check from its own checkout; stamping that
   // checkout's HEAD would name a commit the builder never made. No actor, or
@@ -1144,6 +1226,8 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, merge
     payload.pull_request = { state: 'merged', ...mergeRecord };
     // Landed by the flight with no person in the loop.
     if (merge.self_landed === true) payload.self_landed = true;
+  } else if (openPullRequest) {
+    payload.pull_request = openPullRequest;
   }
   const event = appendTaskEvent(db, {
     taskId: id,
@@ -2491,6 +2575,7 @@ module.exports = {
   getTask,
   listTasks,
   listTasksCached,
+  rowInWorkspace,
   claimTask,
   setLease,
   renewLease,
@@ -2505,6 +2590,7 @@ module.exports = {
   doneTask,
   reapMissionBlockerTasks,
   archiveTask,
+  archiveNotNeeded,
   relabelArchivedTasks,
   readyTask,
   setTaskResult,

package/lib/voice-gate.js

@@ -247,6 +247,7 @@ const LANDING_REASON_SENTENCES = {
   proof_not_executed: 'the proof was written but never actually run, execute the check and record what it showed',
   proof_required: 'no proof was given, say what was run and what it showed',
   proof_unmerged_or_draft_pr_boundary: 'its proof points at an unmerged draft, merge it or prove the work another way',
+  pull_request_open: 'its pull request is still open, so a person has to land it before the job can finish',
   receipt_verifier_failed: 'a saved receipt failed its re-check, fix what it names and re-certify',
   slop_gate: 'the touched prose breaks a deterministic taste rule, fix the named lines and re-certify',
   strict_verify_missing: 'no recorded check command to re-run, add one and re-certify',