atris 3.74.28 → 3.75.0

package/commands/mission.js

@@ -10256,7 +10256,7 @@ async function parseAndValidateMissionRunPhase(args) {
   // safe-lane tasks, build in parallel worktrees, land serially. Humble flag,
   // full loop, see lib/fleet.js. --dry-run previews the staffing only.
   if (hasFlag(args, '--fleet')) {
-    const { runFleetFlight } = require('../lib/fleet');
+    const { runFleetFlight, flightExitCode } = require('../lib/fleet');
     const slots = Math.max(1, Number(readFlag(args, '--slots', '')) || 3);
     // Default: cut build worktrees from origin/master (checkoutBase). --base
     // keeps launcher-HEAD only when the operator asks for it explicitly.
@@ -10268,7 +10268,7 @@ async function parseAndValidateMissionRunPhase(args) {
       ...(baseOverride ? { checkoutBase: baseOverride } : {}),
     });
     if (asJson) console.log(JSON.stringify(flight, null, 2));
-    process.exitCode = flight.paused && flight.paused.length > 0 ? 1 : 0;
+    process.exitCode = flightExitCode(flight);
     context.handled = true;
     return context;
   }

package/commands/rating.js

@@ -24,6 +24,12 @@ function rated(n) {
   return `${/^(8|11$|18$)/.test(String(n)) ? 'an' : 'a'} ${n}`;
 }
 
+// Jobs the build machine could not start (no room on the disk, a build copy that would not open) were let
+// go before any engine ran. They are no member's miss and not finished, and they say so in a line of their own.
+function couldNotStartLine(n) {
+  return `${n} ${n === 1 ? 'job' : 'jobs'} could not start on this machine. ${n === 1 ? 'It doesn\'t' : 'They don\'t'} count against anyone.`;
+}
+
 // Members rated on the last 30 days of jobs here, best first, each with the
 // job and model the roster gives it, plus the build line: what the build
 // engine rates in the combine and what members doing build landed here.
@@ -40,9 +46,9 @@ function readHere(deps = {}) {
   if (!played || played.error || played.no_history) return null;
   const { rosterRows } = require('../lib/gm-season');
   // A member whose only misses were later confirmed not needed, or whose only jobs
-  // wait on a pull request, 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);
+  // 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);
   if (!rows.length) return null;
   let lineup = deps.lineup;
   if (lineup === undefined) lineup = require('../lib/team-lineup').readLineupSafe(root);
@@ -57,7 +63,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 } : {}), 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 } : {}), 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;
@@ -65,9 +71,11 @@ function readHere(deps = {}) {
   const builders = members.filter((m) => m.job === 'build');
   const landed = builders.reduce((sum, m) => sum + m.landed, 0);
   const finished = builders.reduce((sum, m) => sum + m.finished, 0);
+  const couldNotStart = members.reduce((sum, m) => sum + (m.could_not_start || 0), 0);
   return {
     workspace: played.workspace_name || null,
     members,
+    ...(couldNotStart ? { could_not_start: couldNotStart } : {}),
     build: card && finished ? { model: buildModel, combine_ovr: card.ovr, landed, finished, ovr: rating.atrisRating(landed, finished) } : null,
   };
 }
@@ -98,6 +106,7 @@ function renderHere(here) {
     lines.push('', `${head}${shown.join(', ')}${rest ? `, and ${rest} more` : ''}`);
   }
   lines.push('landed: accepted or merged. drops and abandons count against a member.');
+  if (here.could_not_start) lines.push(couldNotStartLine(here.could_not_start));
   if (here.build) {
     const b = here.build;
     lines.push('', `build runs ${modelLabel(b.model)}, ${rated(b.combine_ovr)} in the combine.`,
@@ -116,6 +125,7 @@ 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.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/worktree.js

@@ -589,10 +589,11 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
   // Every new flight pays down completed checkout debt before adding another
   // full repo copy. Branches and commits survive worktree removal, while real
   // uncommitted changes remain protected by cleanupWorktrees.
+  const cleanupBudget = { count: 0, kib: 0 };
   let reapedBeforeStart = [];
   let cachePrunedBeforeStart = [];
   try {
-    const cleaned = cleanupWorktrees({ root, base: mainline, apply: true, by: 'atris worktree start' });
+    const cleaned = cleanupWorktrees({ root, base: mainline, apply: true, by: 'atris worktree start', cleanupBudget });
     reapedBeforeStart = cleaned.removed;
     cachePrunedBeforeStart = cleaned.cachePruned;
   } catch {}
@@ -616,9 +617,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
   const shipBase = checkoutBase;
   if (fs.existsSync(target)) throw new Error(`worktree path already exists: ${target}`);
   // A full disk stops every flight at once. Reap first; refuse before cutting.
-  const room = (spaceGuard ?? !space.isScratchPath(target))
-    ? ensureRoomForCopy({ root, target, freeSpace, env })
-    : null;
+  const room = checkRoomForCopy({ root, target, freeSpace, env, spaceGuard, cleanupBudget });
   fs.mkdirSync(path.dirname(target), { recursive: true });
   const staleBase = refreshRemoteRef(root, checkoutBase);
   // A retry of the same job starts from the last run's unlanded commits; it
@@ -734,13 +733,13 @@ function seedCopyDeps({ root, target, options = {} }) {
 // the engine that just finished may still have its last message unread.
 const LOW_DISK_IDLE_MS = 10 * 60 * 1000;
 
-function ensureRoomForCopy({ root, target, freeSpace = space.freeBytes, env = process.env, by = 'atris worktree start' }) {
+function ensureRoomForCopy({ root, target, freeSpace = space.freeBytes, env = process.env, by = 'atris worktree start', cleanupBudget = null }) {
   const limits = space.spaceLimits(env);
   const before = freeSpace(target);
   const room = { before, free: before, removed: [], cleared: [], ...limits };
   if (typeof before !== 'number' || !Number.isFinite(before)) return room;
   if (before >= limits.reapBelow && before >= limits.refuseBelow) return room;
-  const swept = sweepWorkspace({ workspace: path.dirname(findPrimaryRoot(root)), apply: true, idleMs: LOW_DISK_IDLE_MS, freeSpace, by });
+  const swept = sweepWorkspace({ workspace: path.dirname(findPrimaryRoot(root)), apply: true, idleMs: LOW_DISK_IDLE_MS, freeSpace, by, cleanupBudget });
   for (const repo of swept.repos) {
     room.removed.push(...(repo.removed || []));
     room.cleared.push(...(repo.cachePruned || []));
@@ -763,6 +762,29 @@ function ensureRoomForCopy({ root, target, freeSpace = space.freeBytes, env = pr
   return room;
 }
 
+// When the disk is checked before a copy is cut: spaceGuard says so, else anywhere but a temp folder.
+function checkRoomForCopy({ root, target, freeSpace, env, spaceGuard, cleanupBudget = null }) {
+  return (spaceGuard ?? !space.isScratchPath(target))
+    ? ensureRoomForCopy({ root, target, freeSpace, env, cleanupBudget })
+    : null;
+}
+
+// The question worktree start asks about the disk, asked on its own so a flight can ask it once before it
+// claims anything: the same floor, the same reaping of finished copies, the same words. null when there is
+// room, when the disk cannot be read, or when a copy would land in a temp folder. Otherwise the sentence
+// worktree start would refuse with, and the numbers behind it. Any other trouble is left for worktree start
+// to report when it runs. target names the folder the build will use when it is not worktree start's usual
+// one (a sealed review sandbox is cut in the temp folder).
+function lowDiskRefusal({ root = repoRoot(), member = '', agent = '', task = 'flight', now = new Date(), env = process.env, freeSpace = space.freeBytes, spaceGuard, target = '' } = {}) {
+  try {
+    checkRoomForCopy({ root, target: target ? path.resolve(target) : path.resolve(defaultWorktreePath(root, member || agent, task, now)), freeSpace, env, spaceGuard });
+    return null;
+  } catch (error) {
+    if (!error || error.code !== 'ATRIS_LOW_DISK') return null;
+    return { message: error.message, free: error.space.free, needs: error.space.refuseBelow };
+  }
+}
+
 function startWorktree(args) {
   const root = repoRoot();
   const member = readFlag(args, '--member');
@@ -1694,6 +1716,7 @@ function cleanupWorktrees({
   idleMs = 0,
   freshGraceMs = WORKTREE_REAP_GRACE_MS,
   now = Date.now(),
+  cleanupBudget = null,
 } = {}) {
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
@@ -1706,7 +1729,7 @@ function cleanupWorktrees({
   const removed = [];
   const cacheCandidates = [];
   const cachePruned = [];
-  const cacheBudget = { count: 0, kib: 0 };
+  const cacheBudget = cleanupBudget || { count: 0, kib: 0 };
   const scopePaths = Array.isArray(onlyPaths) ? onlyPaths.map(canonicalPath) : null;
   const inScope = (wtPath) => (!scopePaths || scopePaths.includes(canonicalPath(wtPath)))
     && (!onlyUnder || space.isInside(wtPath, onlyUnder));
@@ -1847,13 +1870,12 @@ function cleanupWorktrees({
 // Removes copies that pass every cleanup check (merged into origin's main
 // branch, nothing changed, untracked, or ignored, nothing running inside)
 // and are unused for idleMs; clears verified webpack caches in the idle
-// copies it keeps; trims the shared install store. Unmerged work always
-// stays.
+// copies it keeps. Shared installs and unmerged work stay for review.
 const SWEEP_IDLE_MS = 2 * 60 * 60 * 1000;
 const SWEEP_EVERY_HOURS = 3;
 const SWEEP_HIDDEN_KEPT = new Set(['primary_checkout', 'current_checkout', 'out_of_scope']);
 
-function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, activeCwds, freeSpace = space.freeBytes, by = 'atris worktree sweep' } = {}) {
+function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, activeCwds, freeSpace = space.freeBytes, by = 'atris worktree sweep', cleanupBudget = null } = {}) {
   const root = path.resolve(workspace);
   const before = freeSpace(root);
   const report = { workspace: root, apply, idle_ms: idleMs, before, after: before, repos: [] };
@@ -1861,6 +1883,8 @@ function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, acti
   // Without a process list nobody can tell which copies are in use.
   if (!Array.isArray(scan)) return { ...report, error: 'could not list running programs, so every copy was kept' };
   const scope = path.join(root, space.AGENT_COPIES_DIR);
+  // One limit covers the whole sweep, not each repository separately.
+  cleanupBudget = cleanupBudget || { count: 0, kib: 0 };
   for (const repo of space.agentCopyRepos(root)) {
     const entry = { name: repo.name, root: repo.root };
     try {
@@ -1872,7 +1896,7 @@ function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, acti
       // A real removal scans again per repo and right before each copy goes;
       // the shared scan only serves previews and tests.
       const shared = Array.isArray(activeCwds) || !apply ? scan : undefined;
-      const result = cleanupWorktrees({ root: repo.root, base, apply, activeCwds: shared, by, onlyUnder: scope, idleMs });
+      const result = cleanupWorktrees({ root: repo.root, base, apply, activeCwds: shared, by, onlyUnder: scope, idleMs, cleanupBudget });
       report.repos.push({
         ...entry,
         base: result.base,
@@ -1881,7 +1905,9 @@ function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, acti
         cachePruned: result.cachePruned,
         cacheCandidates: result.cacheCandidates,
         kept: result.kept.filter((item) => !SWEEP_HIDDEN_KEPT.has(item.reason)),
-        installsPruned: apply ? space.pruneDepsCache({ workspace: root, repoName: repo.name }) : [],
+        // Shared installs may be in use or contain local changes. Leave them
+        // for explicit review rather than pruning by age.
+        installsPruned: [],
       });
     } catch (error) {
       report.repos.push({ ...entry, error: String((error && error.message) || error) });
@@ -2145,6 +2171,7 @@ module.exports = {
   collidingFlights,
   mergePrWithRetry,
   createAgentWorktree,
+  lowDiskRefusal,
   deniedLaneForShip,
   protectedPushRefusal,
   createOrFindPr,