atris 3.74.29 → 3.76.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.
@@ -38,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, 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 = 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);
@@ -57,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 } : {}), 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;
@@ -65,9 +81,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 +116,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 +135,11 @@ 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.
@@ -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
@@ -635,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;
@@ -734,13 +745,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 +774,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');
@@ -770,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)}`);
@@ -804,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'),
@@ -922,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 {
@@ -1694,6 +1736,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 +1749,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 +1890,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 +1903,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 +1916,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 +1925,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) });
@@ -2101,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)');
@@ -2145,6 +2192,7 @@ module.exports = {
   collidingFlights,
   mergePrWithRetry,
   createAgentWorktree,
+  lowDiskRefusal,
   deniedLaneForShip,
   protectedPushRefusal,
   createOrFindPr,