atris 3.75.0 → 3.76.0

package/commands/rating.js

@@ -44,11 +44,21 @@ function readHere(deps = {}) {
     return null;
   }
   if (!played || played.error || played.no_history) return null;
-  const { rosterRows } = require('../lib/gm-season');
+  const { rosterRows, tally } = 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);
@@ -63,7 +73,7 @@ function readHere(deps = {}) {
     }
     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 } : {}) };
+    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 +136,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');

package/commands/worktree.js

@@ -581,7 +581,7 @@ function printStatus() {
 // finished copies across the workspace and then refuses (ATRIS_LOW_DISK),
 // and a matching install is cloned in as node_modules. deps: false skips
 // the clone; an object passes options through to seedNodeModules.
-function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task, branch: branchOverride, path: pathOverride, base: baseOverride, now = new Date(), env = process.env, freeSpace = space.freeBytes, spaceGuard, deps } = {}) {
+function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task, formerTasks = [], branch: branchOverride, path: pathOverride, base: baseOverride, now = new Date(), env = process.env, freeSpace = space.freeBytes, spaceGuard, deps } = {}) {
   const owner = member || agent;
   if (!owner || !task) throw new Error('createAgentWorktree: owner (member/agent) and task required');
   // Pin the caller's flight base, or resolve it once for this new flight.
@@ -634,6 +634,18 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     resumedFrom = null;
     console.error(`note: the last run's branch ${skippedResume} no longer merges cleanly with ${checkoutBase}, so this run starts fresh; that branch keeps its commits`);
   }
+  // A display name is not an identity: it repeats across workspaces and changes when the task list
+  // changes, so a branch under a job's older name is never a starting point and never blocks a
+  // flight. It can still be this job's own unfinished work, so say where it is and leave the choice
+  // to a person; this run goes on from the job's own name.
+  const own = slugify(task, 'task', 36);
+  for (const former of Array.isArray(formerTasks) ? formerTasks : [formerTasks]) {
+    if (!former || !String(former).trim() || slugify(former, 'task', 36) === own) continue;
+    const olderRun = lastRunBranch(root, owner, former, checkoutBase, branch);
+    if (!olderRun) continue;
+    console.error(`note: older unfinished work may be on ${olderRun}; ${resumedFrom ? `continuing from ${resumedFrom} instead` : 'starting fresh'}`);
+    break;
+  }
   const startPoint = resumedFrom || checkoutBase;
   const ref = `refs/heads/${branch}`;
   const existed = runGit(['show-ref', '--verify', '--quiet', ref], { cwd: root, check: false }).status !== 1;
@@ -792,9 +804,12 @@ function startWorktree(args) {
   const owner = member || agent;
   const task = readFlag(args, '--task');
   if (!owner || !task) {
-    console.error('Usage: atris worktree start --member <member>|--agent <name> --task "<short task>" [--claim] [--force] [--no-deps]');
+    console.error('Usage: atris worktree start --member <member>|--agent <name> --task "<short task>" [--former-task "<older name of the task>"] [--claim] [--force] [--no-deps]');
     return 2;
   }
+  // The task's older name, when it has gone by one. It is only mentioned: an unfinished branch under
+  // it is named in one line, never resumed and never a collision (see createAgentWorktree).
+  const formerTask = readFlag(args, '--former-task');
   const memberFile = member ? path.join(root, 'atris', 'team', member, 'MEMBER.md') : '';
   if (memberFile && !fs.existsSync(memberFile)) {
     console.error(`warning: no member persona at ${path.relative(root, memberFile)}`);
@@ -826,6 +841,7 @@ function startWorktree(args) {
       member,
       agent,
       task,
+      formerTasks: formerTask ? [formerTask] : [],
       branch: readFlag(args, '--branch'),
       path: readFlag(args, '--path'),
       base: readFlag(args, '--base') || readFlag(args, '--target'),
@@ -944,15 +960,19 @@ function deniedLaneForShip(root, branch, message) {
       for (const m of source.toUpperCase().matchAll(/([A-Z]{2,6}-\d+)/g)) refs.add(m[1]);
       for (const m of source.toLowerCase().matchAll(/([a-z]{2,6})-(\d+)/g)) refs.add(`${m[1].toUpperCase()}-${m[2]}`);
     }
-    if (!refs.size) return null;
+    // A flight's branch names its job by row id, lowercased, not by the display id a person reads
+    // (flightTaskName in lib/fleet.js), so a branch also finds a job by its row id as a whole word.
+    const words = new Set(String(branch || '').toLowerCase().split(/[^a-z0-9]+/).filter(Boolean));
     const projectionPath = path.join(findPrimaryRoot(root), '.atris', 'state', 'tasks.projection.json');
     if (!fs.existsSync(projectionPath)) return null;
     const projection = JSON.parse(fs.readFileSync(projectionPath, 'utf8'));
     for (const task of projection.tasks || []) {
       const ids = [task.display_id, task.legacy_ref].filter(Boolean).map(v => String(v).toUpperCase());
-      if (!ids.some(id => refs.has(id))) continue;
+      // Only a real row id counts: a short or odd one could match any word in a branch name.
+      const rowId = typeof task.id === 'string' && /^[A-Za-z0-9]{16,}$/.test(task.id) ? task.id.toLowerCase() : '';
+      if (!ids.some(id => refs.has(id)) && !(rowId && words.has(rowId))) continue;
       const hit = protectedLaneOfTask(task);
-      if (hit) return { taskId: ids[0], tag: hit };
+      if (hit) return { taskId: ids[0] || task.id, tag: hit };
     }
     return null;
   } catch {
@@ -2127,8 +2147,9 @@ function help() {
   console.log('Usage: atris worktree <guide|start|ship|status|guard|prune|cleanup|sweep>');
   console.log('');
   console.log('  atris worktree guide');
-  console.log('  atris worktree start --member <member>|--agent <name> --task "<task>" [--claim] [--force] [--no-deps]');
+  console.log('  atris worktree start --member <member>|--agent <name> --task "<task>" [--former-task "<older name>"] [--claim] [--force] [--no-deps]');
   console.log('    --force         start even when another recent flight shares a task word');
+  console.log('    --former-task   the task\'s older name; a branch left unfinished under it is named, never resumed');
   console.log('    --no-deps       do not clone node_modules from a matching install');
   console.log('  atris worktree ship --message "<commit>" --verify "<cmd>" [--merge] [--target <ref>] [--local]');
   console.log('    --target <ref>  override the default landing target (default: branch atris-base, else origin default branch)');

package/lib/fleet.js

@@ -1769,6 +1769,9 @@ module.exports = {
   METHOD_KERNEL,
   ATRIS_BUILD_PROCESS_PREAMBLE,
   buildFleetPrompt,
+  flightTaskName,
+  formerTaskArgs,
+  builtWithArgs,
   assertIsolatedWorktree,
   buildEngineCommand,
   isSafeLane,
@@ -2552,7 +2555,7 @@ function bindOneLapProof(worktreePath, proofRef, sourceCommit) {
   return sourceTree;
 }
 
-function importReviewCommit(boundary, { cli, taskId, engine, expectedCommit = '', expectedTree = '', startBaseArgs = [] } = {}) {
+function importReviewCommit(boundary, { cli, taskId, ref = taskId, engine, expectedCommit = '', expectedTree = '', startBaseArgs = [] } = {}) {
   const fail = (stage, detail, extra = {}) => ({ ok: false, stage, detail: headTail(String(detail || '').trim()), ...extra });
   const runSandbox = (args) => spawnSync('git', args, {
     cwd: boundary.worktreePath,
@@ -2613,7 +2616,7 @@ function importReviewCommit(boundary, { cli, taskId, engine, expectedCommit = ''
     .map((relative) => `${baseByPath.has(relative) ? (sourceByPath.has(relative) ? 'M' : 'D') : 'A'} ${relative}`);
   if (!changedEntries.length) return fail('no_change', 'the verified commit has no tree change');
 
-  const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${String(taskId).toLowerCase()}`, ...startBaseArgs]);
+  const started = cli(['worktree', 'start', '--agent', engine, '--task', flightTaskName('dispatch', ref), ...formerTaskArgs('dispatch', ref, taskId), ...startBaseArgs]);
   const landingPath = (String(started && started.stdout || '').match(/next: cd (.+)/) || [])[1];
   if (!landingPath) return fail('worktree_start', String(started && (started.stderr || started.stdout) || 'could not create review worktree'));
   const worktreePath = landingPath.trim();
@@ -3413,7 +3416,7 @@ async function runFleetFlight({
       const leaseSet = leaseDb.setLease(leaseConnection, { id: leaseId, holder, claimEventId: claims.eventId(leaseId) });
       if (!leaseSet && (!ownCli || leaseDb.getTask(leaseConnection, leaseId))) throw new Error('could not set claim lease');
       if (leaseSet) leased.set(leaseId, holder);
-      const started = cli(['worktree', 'start', '--agent', entry.engine, '--task', `fleet-${String(entry.task.display_id).toLowerCase()}`, ...startBaseArgs]);
+      const started = cli(['worktree', 'start', '--agent', entry.engine, '--task', flightTaskName('fleet', rowRef), ...formerTaskArgs('fleet', rowRef, entry.task.display_id), ...startBaseArgs]);
       const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
       if (!wt) {
         cannotStart('worktree_start', started.stderr.slice(0, 200));
@@ -3621,6 +3624,50 @@ function jobRef(task, displayId) {
   return task && task.id ? String(task.id) : String(displayId);
 }
 
+// The task name a flight gives `worktree start`, which builds the build branch from it. The branch
+// carries the job's row id, lowercased, as one word, because that is what the held-pull-request
+// sweep (`atris task sweep --held`) reads to know a merged pull request is this job's own build
+// and not one a builder named on a row. A display id says nothing like that: the same folder name
+// in another place gives the same ids, and the list can be written again. `ref` is what jobRef
+// gave, so a job shown with no row id keeps its display id, and the sweep will not credit that
+// branch. Both kinds fit the 36 characters `worktree start` keeps of a name with a 26 character id.
+function flightTaskName(kind, ref) {
+  return `${kind}-${String(ref).toLowerCase()}`;
+}
+
+// Before the branch carried the row id it carried the display id a person reads. The flight hands
+// `worktree start` that older name as well, as --former-task, for one purpose: so start can say that
+// unfinished work may be on a branch under it. A display name is not an identity (the same folder
+// name in another place gives the same name, and the list can be written again), so start never
+// resumes a branch under the older name and is never blocked by one: it starts fresh and prints one
+// line naming the branch. Nothing is handed over when there is no display id, or when it makes the
+// same name (a job shown with no row id is named by its display id at every step). The sweep never
+// credits a branch with the older name either.
+function formerTaskArgs(kind, ref, displayId) {
+  if (displayId === undefined || displayId === null || !String(displayId).trim()) return [];
+  const former = flightTaskName(kind, String(displayId).trim());
+  return former === flightTaskName(kind, ref) ? [] : ['--former-task', former];
+}
+
+// A flight that runs for a member claims the job and hands it in under the member's name, so the
+// engines that did the building would never reach the job's history, and either one could later
+// review the work as an independent check. The hand-in also names every engine that ran a build
+// attempt, each by the name it has on a flight with no member (fleet-<engine>). The names the claim
+// and the hand-in already put on the record (`claimedAs`, `handedInAs`) are left out, so a flight
+// with no member and one or two engines names nobody extra. `engines` is the engines in the order
+// they ran. The answer is the flag with its value, or nothing to add.
+function builtWithArgs(engines, { claimedAs = '', handedInAs = '' } = {}) {
+  const { normalizeActor } = require('./review-integrity');
+  const onRecord = new Set([normalizeActor(claimedAs), normalizeActor(handedInAs)]);
+  const names = [];
+  for (const engine of Array.isArray(engines) ? engines : []) {
+    const id = normalizeActor(engine);
+    const name = id ? `fleet-${id}` : '';
+    if (name && !onRecord.has(name) && !names.includes(name)) names.push(name);
+  }
+  return names.length ? ['--built-with', names.join(',')] : [];
+}
+
 // A flight works only on jobs in its own workspace, and the store takes a row id from any
 // workspace, so the flight asks whose workspace the row is in before it claims anything. That is
 // the store's own rule for what a workspace holds (rowInWorkspace, the one its workspace listing
@@ -4263,7 +4310,7 @@ async function runDispatchFlight({
         // earlier finished run's branch must not refuse the retry. Worktree
         // start resumes that branch's commits, or starts fresh when they no
         // longer merge cleanly (the member-path retry fix).
-        const started = cli(['worktree', 'start', '--agent', engine, '--task', `dispatch-${taskId.toLowerCase()}`, '--force', ...startBaseArgs]);
+        const started = cli(['worktree', 'start', '--agent', engine, '--task', flightTaskName('dispatch', rowRef), ...formerTaskArgs('dispatch', rowRef, taskId), '--force', ...startBaseArgs]);
         const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
         if (!wt) {
           const released = releaseUnstartedDispatchClaim(cli, {
@@ -4571,6 +4618,9 @@ async function runDispatchFlight({
   for (const { entry, result, candidate, startedAtMs } of results) {
     const activeEngine = result.engine || entry.engine || engine;
     const readyActor = explicitActor || `fleet-${activeEngine}`;
+    // Every engine that ran a build attempt on this job, for the hand-in to name (see builtWithArgs).
+    const ranEngines = (Array.isArray(result.attempts) ? result.attempts : []).map((attempt) => attempt && attempt.engine);
+    const builtWith = builtWithArgs(ranEngines, { claimedAs: taskActor, handedInAs: readyActor });
     const landingEntry = { ...entry, engine: activeEngine, candidate };
     if (result.restaffed) log(`    restaffed ${entry.taskId}: ${result.restaffed.from} -> ${result.restaffed.to} (${result.restaffed.detail || result.restaffed.reason})`);
     if (result.handover) log(`    handed over ${entry.taskId}: ${result.handover_reason}`);
@@ -4814,6 +4864,7 @@ async function runDispatchFlight({
           const imported = importReviewCommit(entry.remoteBoundary, {
             cli,
             taskId: entry.taskId,
+            ref: jobRef(entry.task, entry.taskId),
             engine: activeEngine,
             expectedCommit: candidate.commit,
             expectedTree: candidate.tree,
@@ -4923,6 +4974,7 @@ async function runDispatchFlight({
           '--landing', 'Operators can review the verified change before it reaches users, reducing the risk of an unreviewed release.',
           '--checked', `${landed.check} passed in the isolated worktree`,
           '--tested', 'The requested behavior passed its declared verifier.',
+          ...builtWith,
           '--as', readyActor,
         ]);
         if (!readyResult || readyResult.status !== 0) {
@@ -4974,6 +5026,7 @@ async function runDispatchFlight({
           '--checked', `${landed.check} passed before the pull request was opened`,
           '--tested', 'The requested behavior passed its declared verifier.',
           ...openPullRequestFlags(landed.pull_request),
+          ...builtWith,
           '--as', readyActor,
         ], { flight, landedRow: heldRow, worktree: entry.worktreePath, heldForReview: true, save: () => writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly: proofOnly, enforceRemoteBoundary }) });
         if (!heldRecorded) {
@@ -5002,6 +5055,7 @@ async function runDispatchFlight({
         '--checked', `${landed.check} passed before landing`,
         '--tested', 'The requested behavior passed its declared verifier.',
         ...landedMergeFlags(landed.merge),
+        ...builtWith,
         '--as', readyActor,
       ], { flight, landedRow, worktree: entry.worktreePath, save: () => writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly: proofOnly, enforceRemoteBoundary }) });
       if (!reviewRecorded) {

package/lib/gm-season.js

@@ -316,6 +316,18 @@ function parseJson(text) {
   }
 }
 
+// When a landing happened. A merge a person made on GitHub is written down later, when the sweep
+// notices it, and its event says when the merge was (landed_at). The rating dates the landing by
+// that, so a merge swept in weeks late does not count as news. It is never later than the event
+// itself, so a time in the future cannot hold a landing inside the window; a time that cannot be
+// read leaves the landing dated when it was written down.
+function landedAt(row, payload) {
+  const written = Number(row.created_at);
+  const text = payload && typeof payload.landed_at === 'string' ? payload.landed_at.trim() : '';
+  const merged = text ? Date.parse(text) : NaN;
+  return Number.isFinite(merged) && Number.isFinite(written) ? Math.min(merged, written) : written;
+}
+
 function landedBy(row, payload) {
   if (payload && (payload.auto_accepted === true || payload.self_landed === true)) return 'autoland';
   return /auto/i.test(String(row.actor || '')) ? 'autoland' : 'you';
@@ -377,7 +389,7 @@ function outcomeFromEvent(row) {
     member: String(member),
     title: row.title || '',
     kind,
-    at: row.event_type === 'claim_expired' && Number.isFinite(leaseUntil) ? leaseUntil : Number(row.created_at),
+    at: row.event_type === 'claim_expired' && Number.isFinite(leaseUntil) ? leaseUntil : kind === 'landed' ? landedAt(row, payload) : Number(row.created_at),
     reason: kind !== 'took' && kind !== 'landed' ? (typeof payload.reason === 'string' && payload.reason.trim() || typeof payload.note === 'string' && payload.note.trim() || null) : null,
     claimed_at: claimedAt,
     landed_by: kind === 'landed' ? landedBy(row, payload) : null,
@@ -665,6 +677,9 @@ function loadSeason(workspaceRoot, { now = Date.now(), days = SEASON_DAYS, dbPat
         title: t.title,
         member: String(t.claimed_by),
         since: Number(t.proof_at || t.last_event_at || t.updated_at || 0),
+        // Done, and its pull request still open for a person to land. The rating never asks
+        // GitHub; `atris task sweep --held` does, and credits the builder when it was merged.
+        ...(taskDb.heldPullRequestOf(t) ? { waiting_on_pull_request: true } : {}),
       }));
     season.claims = live
       .filter(t => t.status === 'claimed' && t.claimed_by)