atris 3.75.0 → 3.77.0

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

@@ -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 || [])]
@@ -316,6 +330,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 +403,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,
@@ -598,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
@@ -665,6 +750,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)
@@ -1267,11 +1355,15 @@ module.exports = {
   lastPlays,
   loadSeason,
   memberRatings,
+  missReasons,
+  openReleasePlays,
+  outcomesAsOf,
   outcomesFromEvents,
   ovr,
   ownerMood,
   readLastSeen,
   rosterRows,
+  SEASON_DAYS,
   seasonBoard,
   sinceLastLook,
   stillStuck,