atris 3.82.1 → 3.82.2

package/README.md

@@ -18,7 +18,7 @@ A computer can be personal or shared by a business. It can run a job like code,
 
 Atris gives Claude Code, Codex, Cursor and any other agent a memory that lasts across sessions. The memory is plain files in your repo: `atris/MAP.md` (where everything lives, with file and line numbers), `atris/wiki/` (what the team learned, as pages linked with `[[page-name]]`), `atris/logs/` (what was done and checked each day), and `atris task` (open work, who claimed it, and the proof). Every agent reads the same files before it acts, so several agents and people share one memory, reviewed in git like code.
 
-Mem0, Zep and Letta remember the users of a chat app. Atris remembers the project. Guide and comparison: https://atris.ai/blog/memory-for-coding-agents
+Mem0, Zep and Letta remember the users of a chat app. Atris remembers the project. Patterns and setup: [docs/agent-memory.md](docs/agent-memory.md). Comparison: https://atris.ai/blog/memory-for-coding-agents
 
 ## Check what ChatGPT can read about your business
 

package/commands/mission.js

@@ -7,7 +7,7 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
-const { memberProcessPrompt } = require('../lib/member-context');
+const { memberProcessPrompt, currentWorkPrompt } = require('../lib/member-context');
 const { memberIdentityLine, missionObjectiveLine } = require('../lib/member-identity');
 const { formatToolStep, formatCodexEvent, appendProgress, reportProgress, startedLine, newRunToken, runMarker } = require('../lib/member-progress');
 const {
@@ -8147,6 +8147,8 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd =
     ...turnDownLines,
     ...(sharedProcess ? ['', sharedProcess] : []),
     ...preloadedContextLines,
+    '',
+    currentWorkPrompt(cwd, { ...mission, verifier: frozen.verifier }),
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,

package/commands/task.js

@@ -10,6 +10,7 @@ const { execSync } = require('node:child_process');
 const path = require('path');
 const os = require('os');
 const { hasFlag } = require('../lib/arg-parser');
+const { buildNextWorkContext, reconcileTaskRows } = require('../lib/next-work-context');
 const { argsWantHelp } = require('../lib/noninteractive');
 const {
   compactErrorPayload,
@@ -74,6 +75,7 @@ const {
 } = require('../lib/task-decision');
 const {
   buildFirstMinute,
+  loadLocalTaskState,
   deskNextCommand,
   firstTalkCommand,
   folderName,
@@ -5880,27 +5882,11 @@ function cmdNextTruth(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const workspaceRoot = taskDb.workspaceRoot();
-  const rows = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
-  const existingProj = readProjectionFile(workspaceRoot);
-  const dbHasActionable = rows.some((task) => {
-    const status = task && task.status;
-    return status === 'open' || status === 'claimed' || status === 'review';
-  });
-  const projHasActionable = Boolean(
-    existingProj
-    && Array.isArray(existingProj.tasks)
-    && existingProj.tasks.some((task) => {
-      const status = task && task.status;
-      return status === 'open' || status === 'claimed' || status === 'review';
-    }),
-  );
+  const snapshot = loadLocalTaskState(workspaceRoot);
   let projection;
   let outPath;
-  if (!dbHasActionable && projHasActionable) {
-    projection = existingProj;
-    outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
-  } else if (rows.length === 0 && existingProj && Array.isArray(existingProj.tasks) && existingProj.tasks.length > 0) {
-    projection = existingProj;
+  if (snapshot.source !== 'database') {
+    projection = { tasks: snapshot.tasks };
     outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
   } else {
     const written = writeDefaultProjection(taskDb, db);
@@ -5928,6 +5914,7 @@ function cmdNextTruth(args) {
       scope: normalizeTaskQueueScope(scope),
       projection_path: outPath,
       task: task ? compactTaskFromProjection(projection, task.id) : null,
+      context: buildNextWorkContext({ root: workspaceRoot, tasks: reconcileTaskRows(snapshot.tasks, projection.tasks || []), selected: task, owner: String(owner), taskSource: snapshot.source, generatedAt: snapshot.generated_at }),
     });
     return;
   }

package/commands/worktree.js

@@ -12,10 +12,12 @@ const worktreeCore = require('../lib/worktree-core');
 
 const {
   ATRIS_BIN,
+  RESCUE_IDLE_MS,
+  finishShippedCopy,
+  formatKib,
   SWEEP_IDLE_MS,
   SWEEP_EVERY_HOURS,
   SWEEP_KEPT_LABELS,
-  announceShippedCopyRemoval,
   assertOneLapProofTree,
   baseBranchName,
   branchName,
@@ -50,6 +52,7 @@ const {
   prMergeRef,
   protectedPushRefusal,
   readOneLapProofBinding,
+  reapPushedCopy,
   reapShippedCopy,
   recordWorktreeRemoval,
   refreshMovedMapRefs,
@@ -190,6 +193,7 @@ function shipHelp() {
   console.log('  protected-lane tasks (billing, money, deploy, feedback, ...) can be pushed for review without --merge;');
   console.log('  landing one with --merge or --local needs --allow-denied-lane on written order');
   console.log('  --no-map-refresh  skip the automatic refresh of moved map line references');
+  console.log('  --keep-copy     keep this build copy; by default it is removed once the work lands or is pushed');
   console.log('  unstaged regenerated adapter files are skipped unless staged first or named in --message');
   console.log('  recommended flight verify: npm run test:fast && node --test <focused files>');
 }
@@ -204,6 +208,7 @@ function shipWorktree(args) {
   const noPr = hasFlag(args, '--no-pr');
   const localMode = hasFlag(args, '--local') || hasFlag(args, '--local-merge');
   const merge = hasFlag(args, '--merge');
+  const keepCopy = hasFlag(args, '--keep-copy');
   const message = readFlag(args, '--message') || readFlag(args, '-m');
   const verify = readFlag(args, '--verify');
   let branch = currentBranch(root);
@@ -351,7 +356,7 @@ function shipWorktree(args) {
     }
     console.log('pr: skipped (local mode)');
     if (merge && !dryRun) runShipHealthCheck(primary || root);
-    if (landedOn) announceShippedCopyRemoval(scheduleShippedCopyRemoval({ root, primary, branch, base: landedOn }));
+    if (landedOn) finishShippedCopy({ root, primary, branch, landedOn, keep: keepCopy });
     console.log('done: worktree shipped');
     return 0;
   }
@@ -385,6 +390,7 @@ function shipWorktree(args) {
         }
         if (state.state === 'OPEN' && !state.mergedAt) {
           console.log('merge: pending; kept the source branch while required checks finish');
+          finishShippedCopy({ root, primary, branch, keep: keepCopy });
           return 0;
         }
         if (state.state !== 'MERGED' || !state.mergedAt) {
@@ -414,7 +420,7 @@ function shipWorktree(args) {
     }, { worktree: root });
   } catch {}
   if (merge && !dryRun) runShipHealthCheck(primary || root);
-  if (landedOn) announceShippedCopyRemoval(scheduleShippedCopyRemoval({ root, primary, branch, base: landedOn }));
+  if (!dryRun) finishShippedCopy({ root, primary, branch, landedOn, keep: keepCopy });
   console.log('done: worktree shipped');
   return 0;
 }
@@ -425,7 +431,10 @@ function reapShipped() {
     console.error('reap-shipped: ATRIS_REAP_WORKTREE is not set');
     return 2;
   }
-  const result = reapShippedCopy({ root: process.cwd(), target, base: process.env.ATRIS_REAP_BASE || '' });
+  const base = process.env.ATRIS_REAP_BASE || '';
+  const result = base
+    ? reapShippedCopy({ root: process.cwd(), target, base })
+    : reapPushedCopy({ primary: process.cwd(), target, branch: process.env.ATRIS_REAP_BRANCH || '' });
   console.log(`reap-shipped: ${result.removed ? 'removed' : 'kept'} ${target} (${result.reason})`);
   return result.removed ? 0 : 1;
 }
@@ -495,8 +504,14 @@ function sweep(args) {
     console.error('Usage: atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours <n>]');
     return 2;
   }
+  const rescueDays = Number(readFlag(args, '--rescue-after-days', process.env.ATRIS_WORKTREE_RESCUE_DAYS || String(RESCUE_IDLE_MS / 86400000)));
+  if (!Number.isFinite(rescueDays) || rescueDays <= 0) {
+    console.error('Usage: atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours <n>] [--rescue] [--rescue-after-days <n>]');
+    return 2;
+  }
   const apply = hasFlag(args, '--apply');
-  const report = sweepWorkspace({ workspace, apply, idleMs: idleHours * 3600000 });
+  const rescue = hasFlag(args, '--rescue');
+  const report = sweepWorkspace({ workspace, apply, rescue, idleMs: idleHours * 3600000, rescueIdleMs: rescueDays * 86400000 });
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify({ ok: !report.error, ...report }, null, 2));
     return report.error ? 1 : 0;
@@ -514,9 +529,11 @@ function sweep(args) {
       console.log(`${repo.name}: skipped (${repo.error || repo.skipped})`);
       continue;
     }
-    const gone = apply ? repo.removed : repo.candidates;
+    const saved = apply ? repo.rescued : repo.rescueCandidates;
+    const savedSet = new Set(saved);
+    const gone = (apply ? repo.removed : repo.candidates).filter((item) => !savedSet.has(item));
     const cleared = apply ? repo.cachePruned : repo.cacheCandidates.filter((item) => item.reason === 'generated_webpack_cache');
-    removedTotal += gone.length;
+    removedTotal += gone.length + saved.length;
     clearedTotal += cleared.length;
     reviewTotal += repo.cacheCandidates.filter((item) => item.reason === 'manual_review_required').length;
     const counts = {};
@@ -526,7 +543,18 @@ function sweep(args) {
     }
     const keptText = Object.entries(counts).map(([label, count]) => `${count} ${label}`).join(', ');
     console.log(`${repo.name}: ${apply ? 'removed' : 'would remove'} ${plural(gone.length, 'finished copy', 'finished copies')}, ${apply ? 'cleared' : 'would clear'} ${plural(cleared.length, 'webpack cache', 'webpack caches')}; kept ${repo.kept.length}${keptText ? ` (${keptText})` : ''}`);
+    if (saved.length) console.log(`  ${apply ? 'saved and removed' : 'would save and remove'} ${plural(saved.length, 'abandoned copy', 'abandoned copies')}`);
+    for (const item of saved) {
+      const what = item.reason === 'pushed_branch' ? 'already on origin' : `${plural(item.changed_files || 0, 'changed file', 'changed files')}, idle ${item.idle_days} days`;
+      console.log(`  ${apply ? 'saved' : 'save'}: ${item.path} -> origin/${item.rescue_branch} (${what}, ${formatKib(item.size_kib)})`);
+    }
     for (const item of gone) console.log(`  ${apply ? 'removed' : 'remove'}: ${item.path}`);
+    for (const item of repo.kept) {
+      if (item.reason === 'rescue_push_failed') console.log(`  kept: ${item.path} (could not push its work to origin/${item.rescue_branch}: ${item.error})`);
+      if (item.reason === 'unprovable') console.log(`  kept: ${item.path} (${item.why})`);
+      if (item.reason === 'stale_dirty' || item.reason === 'stale_unpushed') console.log(`  stale: ${item.path} (idle ${item.idle_days} days; atris worktree sweep --rescue --apply saves and removes it)`);
+      if (item.reason === 'ignored_data' && item.files) console.log(`  kept: ${item.path} (ignored files atris cannot rebuild: ${item.files.join(', ')})`);
+    }
     for (const item of cleared) console.log(`  ${apply ? 'cleared' : 'clear'}: ${item.path}`);
   }
   if (reviewTotal) console.log(`review: ${plural(reviewTotal, 'other build folder waits', 'other build folders wait')} for a person; \`atris worktree cleanup\` in each repo lists them`);
@@ -603,7 +631,8 @@ function guide() {
   console.log('Start reaps completed checkouts first. Cleanup preserves branches, source changes, and files git ignores, skips live work, and prunes only verified webpack caches.');
   console.log('Start clones node_modules from a matching install when package-lock.json matches; skip npm ci when it prints "deps: cloned".');
   console.log('Below 25 GB free, start reaps finished copies in every repo; below 10 GB it refuses (ATRIS_WORKTREE_REAP_BELOW_GB, ATRIS_WORKTREE_MIN_FREE_GB).');
-  console.log('A copy shipped with --merge is removed once nothing has run in it for 10 minutes (ATRIS_WORKTREE_KEEP_AFTER_SHIP=1 keeps it).');
+  console.log('A shipped copy is removed as soon as its work is merged or on origin and nothing else runs in it; if something does, a merged copy goes once it has been quiet for 10 minutes (--keep-copy or ATRIS_WORKTREE_KEEP_AFTER_SHIP=1 keeps it).');
+  console.log('The sweep reports abandoned copies with unsaved work (idle 7 days). With --rescue it saves one to commits on a new atris-rescue/ branch, pushes it, and removes the copy only after origin has it; it removes a copy only when it can prove every byte is saved, and anything unusual keeps the copy for a person. The timer never rescues. Rescues are logged in .atris/state/worktree_removals.jsonl.');
   console.log('Use `atris worktree status` to see all worktrees and dirty counts.');
   return 0;
 }
@@ -620,12 +649,14 @@ function help() {
   console.log('    --target <ref>  override the default landing target (default: branch atris-base, else origin default branch)');
   console.log('    --local         merge into the local primary checkout instead of pushing and opening a PR');
   console.log('    --no-map-refresh  skip the automatic refresh of moved map line references');
+  console.log('    --keep-copy     keep this build copy after it ships');
   console.log('    recommended verify: npm run test:fast && node --test <focused files>');
   console.log('  atris worktree status');
   console.log('  atris worktree guard [--allow-primary] [--allow-dirty]');
   console.log('  atris worktree prune [--apply]');
   console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]  reap completed checkouts and verified webpack caches');
-  console.log('  atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours 2]  reap merged, idle copies in every repo');
+  console.log('  atris worktree sweep [--apply] [--json] [--workspace <dir>] [--idle-hours 2] [--rescue] [--rescue-after-days 7]');
+  console.log('    removes merged or pushed idle copies in every repo and reports abandoned ones; --rescue saves those to a new branch on origin, then removes them');
   console.log('  atris worktree sweep --install [--every 3] | --uninstall  run the sweep on a timer');
 }
 

package/lib/first-minute.js

@@ -8,6 +8,7 @@ const { spawnSync } = require('child_process');
 const { isGenericScratchRoot } = require('./scratch-root');
 const { resolveDefaultVerifier } = require('./default-verifier');
 const { nonFalsifyingIssue } = require('./accept-verify-gate');
+const { reconcileTaskRows } = require('./next-work-context');
 
 const FIRST_USE_COMMAND = 'atris "help me choose the first useful step for this project"';
 const FIRST_TALK_ASK = 'what do you want here';
@@ -176,8 +177,10 @@ function titlesFromTodoSection(root, section) {
   }
 }
 
-function loadLocalTasks(root = process.cwd()) {
+function loadLocalTaskState(root = process.cwd(), { taskIds = [] } = {}) {
   let dbRows = [];
+  let lookup = () => null;
+  let databaseRead = false;
   try {
     const taskDb = require('./task-db');
     // Reading never creates the db, so a first look writes nothing.
@@ -185,20 +188,49 @@ function loadLocalTasks(root = process.cwd()) {
     const db = taskDb.open();
     const workspaceRoot = taskDb.workspaceRoot(root);
     const rows = taskDb.listTasks(db, { workspaceRoot, limit: 200 });
+    // Busy queues must not crowd the last outcomes out of the handoff.
+    const recent = ['done', 'failed'].flatMap((status) => taskDb.listTasks(db, { workspaceRoot, status, limit: 3, orderBy: 'updated_at' }));
+    const seen = new Set(rows.map((row) => row.id));
+    rows.push(...recent.filter((row) => !seen.has(row.id)));
     if (Array.isArray(rows) && rows.length) dbRows = taskDb.withTaskDisplayRefs(rows);
+    databaseRead = true;
+    lookup = (id) => {
+      const row = taskDb.getTask(db, id);
+      // A foreign id in a damaged projection is not this workspace's work.
+      if (row && !taskDb.rowInWorkspace(row, workspaceRoot)) return false;
+      return row ? taskDb.withTaskDisplayRefs([row])[0] : null;
+    };
+    // A shortlist is an output budget, not authority to invent a bound job.
+    for (const id of taskIds.slice(0, 8)) {
+      if (dbRows.some((row) => row.id === id)) continue;
+      const row = lookup(id);
+      if (row) dbRows.push(row);
+    }
   } catch {
     // Fall through to the local projection. Tests and fresh folders often have no db.
   }
-  if (dbRows.some(isActionableTask)) return dbRows;
+  if (dbRows.some(isActionableTask)) return { tasks: dbRows, source: 'database' };
   const projectionPath = path.join(root, '.atris', 'state', 'tasks.projection.json');
   try {
     const parsed = JSON.parse(fs.readFileSync(projectionPath, 'utf8'));
+    if (parsed.workspace_root && path.resolve(parsed.workspace_root) !== path.resolve(require('./task-db').workspaceRoot(root))) {
+      return { tasks: dbRows, source: databaseRead ? 'database' : 'none' };
+    }
     const projected = Array.isArray(parsed.tasks) ? parsed.tasks : [];
-    if (projected.some(isActionableTask) || !dbRows.length) return projected;
+    if (projected.some(isActionableTask) || !dbRows.length) {
+      const tasks = reconcileTaskRows(dbRows, projected, lookup);
+      const known = new Set(dbRows.map((row) => row.id));
+      const unknown = tasks.some((row) => !row.id || (!known.has(row.id) && !lookup(row.id)));
+      return { tasks, source: unknown || !databaseRead ? (dbRows.length ? 'mixed' : 'projection') : 'database', generated_at: parsed.generated_at || null };
+    }
   } catch {
     // Keep any done-only db rows below.
   }
-  return dbRows;
+  return { tasks: dbRows, source: databaseRead ? 'database' : 'none' };
+}
+
+function loadLocalTasks(root = process.cwd()) {
+  return loadLocalTaskState(root).tasks;
 }
 
 function loadLatestRecap(root = process.cwd()) {
@@ -1170,6 +1202,7 @@ module.exports = {
   spokenBuiltList,
   taskStartedAt,
   loadLocalTasks,
+  loadLocalTaskState,
   firstTalkBuildCommand,
   renderWhatsNextAsk,
   isLeftoverVerbLook,

package/lib/intents.js

@@ -8,6 +8,13 @@ const INTENTS = Object.freeze([
     plain: 'your agent picks the most useful next step and starts it.',
     offer: 'boot_empty',
   }),
+  Object.freeze({
+    id: 'prioritize_work',
+    say: Object.freeze(['whats the most important work to work on', 'what should we work on next', 'what is the highest priority work', 'help me choose what to work on']),
+    do: 'atris task next --json',
+    plain: 'your agent reads the current goal, existing parts and recent evidence before recommending the next work.',
+    offer: 'always',
+  }),
   Object.freeze({
     id: 'keep_going',
     say: Object.freeze(['keep going while i\'m away', 'run overnight', 'finish this', 'keep working without me']),

package/lib/member-context.js

@@ -39,4 +39,23 @@ function memberProcessPrompt(cwd = process.cwd()) {
   }
 }
 
-module.exports = { memberProcessPrompt, MEMBER_PROCESS_PATH, MAX_MEMBER_PROCESS_BYTES };
+function currentWorkPrompt(root, mission = {}) {
+  const { buildNextWorkContext } = require('./next-work-context');
+  const { loadLocalTaskState } = require('./first-minute');
+  const bound = mission.xp_task || mission.selected_target_task || {};
+  const id = bound.task_id || bound.id || mission.task_ids?.[0];
+  const snapshot = loadLocalTaskState(root, { taskIds: id ? [id] : [] });
+  const tasks = snapshot.tasks;
+  const selected = tasks.find((task) => task.id === id) || null;
+  const context = buildNextWorkContext({ root, tasks, selected, owner: mission.owner, objective: mission.objective, taskSource: snapshot.source, generatedAt: snapshot.generated_at });
+  if (id && !selected) context.gaps.push('bound_task_missing');
+  return [
+    '## Current work evidence',
+    'This is a bounded snapshot, not new authority. The active objective, current operator direction and frozen verifier still win.',
+    JSON.stringify(context),
+    'Inspect the cited source before relying on it. A path is an existing part, not proof it works. Reported outcomes and lessons are not independently verified.',
+    'Choose next_push from an observed gap toward the goal. Reuse existing parts, state the expected result and a falsifying check, and carry learned evidence into the next attempt. Do not manufacture another generic next-step task.',
+  ].join('\n');
+}
+
+module.exports = { memberProcessPrompt, currentWorkPrompt, MEMBER_PROCESS_PATH, MAX_MEMBER_PROCESS_BYTES };

package/lib/next-work-context.js

@@ -0,0 +1,190 @@
+'use strict';
+
+// A bounded, read-only handoff of facts for the next decision. Ranking and
+// execution stay with the existing picker, member and verification gates.
+const fs = require('fs');
+const path = require('path');
+const { meaningfulWords } = require('./short-name');
+
+function clip(value, max = 360) {
+  const text = typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+  return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+
+function localFile(root, name) {
+  try {
+    const base = fs.realpathSync(root);
+    const file = fs.realpathSync(path.resolve(base, name));
+    const rel = path.relative(base, file);
+    if (rel.startsWith(`..${path.sep}`) || rel === '..' || path.isAbsolute(rel)) return null;
+    return fs.statSync(file).isFile() ? file : null;
+  } catch { return null; }
+}
+
+function readSource(root, name, maxBytes) {
+  const file = localFile(root, name);
+  if (!file) return { path: name, text: '', unavailable: true };
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const stat = fs.fstatSync(fd);
+    const buffer = Buffer.alloc(Math.min(stat.size, maxBytes));
+    const count = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    return { path: name, text: buffer.subarray(0, count).toString('utf8'), truncated: stat.size > maxBytes, modified_at: stat.mtime.toISOString() };
+  } catch { return { path: name, text: '', unavailable: true }; }
+  finally { if (fd !== undefined) fs.closeSync(fd); }
+}
+
+// Keep the offline projection fallback, but a known row's current database
+// status always wins. Include finished rows so their outcomes are not lost.
+function reconcileTaskRows(rows, projected, lookup = () => null) {
+  const known = new Map(rows.map((row) => [row.id, row]));
+  const seen = new Set();
+  const merged = [];
+  for (const row of projected) {
+    if (!row || typeof row !== 'object') continue;
+    // Older offline snapshots have only a display reference. Preserve that
+    // evidence without pretending it has a database identity or authority.
+    if (!row.id) { merged.push(row); continue; }
+    if (seen.has(row.id)) continue;
+    seen.add(row.id);
+    const current = known.get(row.id) || lookup(row.id);
+    if (current !== false) merged.push(current || row);
+  }
+  return [...merged, ...rows.filter((row) => !seen.has(row.id))];
+}
+
+function matchingParts(root, map, query) {
+  const wanted = new Set(meaningfulWords(query, 100));
+  const found = new Map();
+  map.text.split(/\r?\n/).forEach((line, index) => {
+    if (!line.startsWith('|')) return;
+    const score = meaningfulWords(line, 100).filter((word) => wanted.has(word)).length;
+    if (!score) return;
+    for (const match of line.matchAll(/`([^`]+)`/g)) {
+      const name = match[1].replace(/:\d+$/, '');
+      if (path.isAbsolute(name) || !localFile(root, name) || found.has(name)) continue;
+      found.set(name, { path: name, source: `${map.path}:${index + 1}`, description: clip(line.replace(/`/g, ''), 180), score });
+    }
+  });
+  return [...found.values()].sort((a, b) => b.score - a.score).slice(0, 5)
+    .map(({ score, ...part }) => part);
+}
+
+function recentOutcomes(tasks, selected) {
+  return tasks.filter((task) => ['done', 'failed', 'review'].includes(task.status))
+    .sort((a, b) => Number(b.id === selected?.id) - Number(a.id === selected?.id)
+      || Number(b.updated_at || 0) - Number(a.updated_at || 0))
+    .slice(0, 3).map((task) => {
+      const meta = task.metadata || {};
+      return {
+        task_id: clip(task.id, 120),
+        title: clip(task.title, 160),
+        status: task.status,
+        result: clip(task.result || meta.result),
+        lesson: clip(task.review?.lesson || meta.latest_agent_lesson),
+        next: clip(task.review?.next_task || meta.latest_agent_next_task),
+        proof: clip(task.review?.proof || meta.latest_agent_proof),
+        validation: task.status === 'failed' ? 'failed' : task.status === 'review' ? 'review_pending'
+          : meta.accepted_by && meta.accepted_at ? 'accepted' : 'reported',
+      };
+    });
+}
+
+function otherOwner(task, owner) {
+  const assigned = typeof task.metadata?.assigned_to === 'string' ? task.metadata.assigned_to.trim() : '';
+  return Boolean((task.claimed_by && task.claimed_by !== owner) || (assigned && assigned !== owner));
+}
+
+function candidateEvidence(tasks, selected, goal, owner) {
+  const words = new Set(meaningfulWords(goal?.text, 100));
+  const { heldForPerson } = require('./member-task-pick');
+  return tasks.filter((task) => task.id !== selected?.id && ['open', 'claimed', 'review'].includes(task.status))
+    .map((task) => {
+      const meta = task.metadata || {};
+      const why = clip(meta.why_it_matters || task.explanation?.why_it_matters, 240);
+      const overlap = new Set(meaningfulWords(`${task.title} ${meta.objective || ''} ${why}`, 100).filter((word) => words.has(word))).size;
+      return {
+        task_id: clip(task.id, 120), title: clip(task.title, 160), status: task.status,
+        owner: clip(task.claimed_by || meta.assigned_to, 80) || null,
+        why: why || null,
+        held: heldForPerson(task) || (otherOwner(task, owner) ? 'other_owner' : null),
+        goal_word_overlap: overlap,
+      };
+    }).sort((a, b) => b.goal_word_overlap - a.goal_word_overlap).slice(0, 3);
+}
+
+function buildNextWorkContext({ root, tasks = [], selected = null, owner = '', taskSource = 'projection', objective = '', generatedAt = null }) {
+  const scoreboard = readSource(root, '.atris/state/scoreboard.json', 16384);
+  const map = readSource(root, 'atris/MAP.md', 65536);
+  let goal = null;
+  try {
+    const value = scoreboard.truncated ? null : JSON.parse(scoreboard.text);
+    if (clip(value?.goal)) goal = { text: clip(value.goal, 600), source: scoreboard.path, updated_at: typeof value.updated_at === 'string' ? clip(value.updated_at, 80) : null };
+  } catch { /* Missing or unreadable knowledge stays unknown. */ }
+  const meta = selected?.metadata || {};
+  const rawCheck = typeof (meta.verify || meta.verifier) === 'string' ? (meta.verify || meta.verifier).trim() : '';
+  // Never offer an ellipsis as an executable command.
+  const check = rawCheck.length <= 600 ? rawCheck : '';
+  const { taskCheck, heldForPerson } = require('./member-task-pick');
+  const runnable = check && taskCheck({ metadata: { verify: check } }).runnable;
+  const parts = matchingParts(root, map, [objective, selected?.title, meta.objective, goal?.text].filter(Boolean).join(' '));
+  const gaps = [];
+  if (!goal) gaps.push('current_goal_missing');
+  if (taskSource === 'none') gaps.push('task_state_missing');
+  if (scoreboard.truncated) gaps.push('goal_source_truncated');
+  if (map.unavailable) gaps.push('parts_map_missing');
+  else if (!parts.length) gaps.push('matching_parts_missing');
+  if (map.truncated) gaps.push('parts_map_truncated');
+  if (selected && !runnable) gaps.push('runnable_check_missing');
+  if (rawCheck.length > 600) gaps.push('check_too_large_for_snapshot');
+  if (taskSource === 'projection' || taskSource === 'mixed') gaps.push('task_snapshot_not_authoritative');
+  if (generatedAt && Date.now() - Date.parse(generatedAt) > 3 * 86400000) gaps.push('task_snapshot_stale');
+  const why = clip(meta.why_it_matters || selected?.explanation?.why_it_matters);
+  if (selected && !why) gaps.push('reason_missing');
+  let kind = selected && runnable ? 'execute' : 'discover';
+  if (gaps.includes('task_snapshot_not_authoritative') || gaps.includes('task_snapshot_stale')) kind = 'discover';
+  let reason = selected ? 'Inspect the relevant source and establish the missing evidence before changing it.'
+    : 'No selectable job is recorded. Find one observed gap toward the current goal, with a falsifying check.';
+  if (kind === 'execute') reason = why || 'Run the recorded check against the relevant source before claiming progress.';
+  if (selected && !['open', 'claimed', 'review'].includes(selected.status)) {
+    kind = 'discover'; reason = 'The bound task is no longer active. Inspect its recorded result before proposing another gap.';
+    gaps.push(selected.status === 'done' ? 'bound_task_already_finished' : 'bound_task_not_active');
+  } else if (selected && heldForPerson(selected)) { kind = 'human_decision'; reason = 'This work is held for a person by the existing task policy.'; }
+  else if (selected?.status === 'review') {
+    const certified = selected.review?.agent_certified || meta.agent_certified || Number(meta.agent_review_pass_count) >= 2;
+    kind = certified ? 'human_decision' : selected.claimed_by === owner ? 'wait' : 'review';
+    reason = certified ? 'The recorded work needs human acceptance.' : 'A different actor must check the finished diff before more work is chosen.';
+  } else if (selected && otherOwner(selected, owner)) {
+    kind = 'wait'; reason = 'Another owner holds this job. Do not duplicate their work.';
+  }
+  const context = {
+    schema: 'atris.next_work_context.v1',
+    workspace_root: path.resolve(root),
+    captured_at: new Date().toISOString(),
+    task_source: taskSource,
+    goal,
+    parts,
+    candidates: candidateEvidence(tasks, selected, goal, owner),
+    recent_outcomes: recentOutcomes(tasks, selected),
+    gaps,
+    next_step: { kind, reason, check: check || null },
+    sources: [scoreboard, map].map(({ text, ...source }) => source),
+    selection_basis: 'existing queue policy; candidate keyword overlap is a discovery hint, not measured business value',
+  };
+  // Keep the packet bounded even with long unicode text or unusual paths.
+  while (Buffer.byteLength(JSON.stringify(context)) > 10000) {
+    if (!gaps.includes('context_budget_limited')) gaps.push('context_budget_limited');
+    if (context.parts.length) context.parts.pop();
+    else if (context.candidates.length) context.candidates.pop();
+    else if (context.recent_outcomes.length) context.recent_outcomes.pop();
+    else {
+      context.next_step.check = null;
+      if (context.next_step.kind === 'execute') context.next_step.kind = 'discover';
+      break;
+    }
+  }
+  return context;
+}
+
+module.exports = { buildNextWorkContext, reconcileTaskRows };

package/lib/task-db.js

@@ -545,7 +545,7 @@ function rowInWorkspace(row, ws) {
   return Boolean(rowRoot) && workspaceViewRoots(ws).includes(rowRoot);
 }
 
-function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
+function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit, orderBy }) {
   const where = [];
   const args = [];
   if (ws) {
@@ -560,6 +560,7 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
     FROM tasks
     ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
     ORDER BY
+      ${orderBy === 'updated_at' ? 'updated_at DESC,' : ''}
       CASE status WHEN 'open' THEN 0 WHEN 'claimed' THEN 1 WHEN 'review' THEN 2 WHEN 'failed' THEN 3 WHEN 'done' THEN 4 WHEN 'archived' THEN 5 ELSE 6 END,
       CASE WHEN tag='endgame' THEN 0 ELSE 1 END,
       created_at DESC

package/lib/worktree-core.js

@@ -52,7 +52,8 @@ function runGit(args, { cwd = process.cwd(), check = true, timeout } = {}) {
   const network = ['fetch', 'push', 'ls-remote'].includes(args[0]);
   // Only network calls need the SSH probe; local calls skip its extra git spawn.
   const defaultTimeout = args[0] === 'push' ? GIT_PUSH_TIMEOUT_MS : network ? 30000 : undefined;
-  const options = { cwd, encoding: 'utf8', timeout: timeout ?? defaultTimeout,
+  // Listing a large repo's index or files can pass the 1 MB default buffer.
+  const options = { cwd, encoding: 'utf8', timeout: timeout ?? defaultTimeout, maxBuffer: COMMAND_MAX_BUFFER_BYTES,
     killSignal: 'SIGKILL', env: network ? gitNetworkEnvironment(process.env, cwd) : undefined };
   let result = spawnSync('git', args, options);
   // Linked checkouts share config. A concurrent start must not silently lose
@@ -1092,14 +1093,14 @@ function worktreeHasActiveProcess(worktreePath, activeCwds) {
   });
 }
 
-function recordWorktreeRemoval(root, { path: removedPath, branch = '', by, reason }) {
+function recordWorktreeRemoval(root, { path: removedPath, branch = '', by, reason, ...details }) {
   try {
     const common = runGit(['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: root, check: false });
     const main = common.status === 0 ? path.dirname(common.stdout.trim()) : root;
     const file = path.join(main, '.atris', 'state', 'worktree_removals.jsonl');
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.appendFileSync(file, `${JSON.stringify({
-      at: new Date().toISOString(), path: removedPath, branch: branch || null, by, reason, pid: process.pid,
+      at: new Date().toISOString(), path: removedPath, branch: branch || null, by, reason, ...details, pid: process.pid,
     })}\n`);
   } catch {}
 }
@@ -1195,6 +1196,478 @@ function originBaseIsCurrent(root, base) {
     && match[2] === `refs/heads/${branch}` && local.stdout.trim() === match[1];
 }
 
+// The guarantee: a copy is removed only when every byte in it is proven saved
+// (committed and on origin) or proven throwaway. Anything unusual, or anything
+// the checks cannot read, keeps the copy for a person.
+//
+// Throwaway ignored folders are matched by exact place, never by name alone:
+// an install or cache folder right beside the package file that makes it
+// (package.json for node_modules, .next, .cache, .turbo; pyproject.toml,
+// setup.py or setup.cfg for the Python test caches). uploads/.cache/ and a
+// .cache/ with no package.json beside it are not throwaway.
+const JS_THROWAWAY_DIRS = new Set(['node_modules', '.next', '.cache', '.turbo']);
+const JS_PACKAGE_FILES = ['package.json'];
+const PY_THROWAWAY_DIRS = new Set(['.pytest_cache', '.mypy_cache', '.ruff_cache']);
+const PY_PACKAGE_FILES = ['pyproject.toml', 'setup.py', 'setup.cfg'];
+// Written by atris itself at the top of a copy: the start sidecar, prompt
+// files, watchdogs, its scratch and cache folders, and command usage counts.
+const ATRIS_PLUMBING_IGNORED = /^\.atris\/(?:agent-worktree\.json|fleet-prompt-[^/]+\.md|codex-watchdog\.js|codex-watchdog-[^/]+\.json|runtime-tmp\/.*|cache\/.*|state\/usage\.jsonl)$/;
+const THROWAWAY_IGNORED_FILE = /^(?:(?:.*\/)?\.DS_Store|tsconfig\.tsbuildinfo|next-env\.d\.ts)$/;
+const IGNORED_WALK_LIMIT = 20000;
+const RESCUE_IDLE_MS = 7 * DAY_MS;
+
+function throwawayIgnoredDir(wtPath, relative) {
+  const name = path.basename(relative);
+  const parent = path.dirname(relative);
+  // Even at the top of the copy, a cache counts only beside the package file that makes it.
+  const besidePackage = (files) => files.some((file) => {
+    try { return fs.lstatSync(path.join(wtPath, parent, file)).isFile(); } catch { return false; }
+  });
+  if (JS_THROWAWAY_DIRS.has(name)) return besidePackage(JS_PACKAGE_FILES);
+  if (PY_THROWAWAY_DIRS.has(name)) return besidePackage(PY_PACKAGE_FILES);
+  // Python bytecode folders sit beside every module; one counts only when it
+  // holds nothing but .pyc files.
+  if (name === '__pycache__') {
+    try {
+      return fs.readdirSync(path.join(wtPath, relative), { withFileTypes: true })
+        .every((entry) => entry.isFile() && entry.name.endsWith('.pyc'));
+    } catch { return false; }
+  }
+  return false;
+}
+
+function throwawayIgnoredFile(relative) {
+  return THROWAWAY_IGNORED_FILE.test(relative) || ATRIS_PLUMBING_IGNORED.test(relative);
+}
+
+// Ignored files in a copy that removal would lose: everything git ignores that
+// is not proven throwaway. null when the copy cannot be read or holds too many
+// files to check.
+function ignoredFilesToKeep(wtPath) {
+  const listed = runGit(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], { cwd: wtPath, check: false });
+  if (listed.status !== 0 || listed.error) return null;
+  const keepers = [];
+  let walked = 0;
+  for (const entry of String(listed.stdout || '').split('\0').filter(Boolean)) {
+    const clean = entry.replace(/\/+$/, '');
+    if (!entry.endsWith('/')) {
+      if (!throwawayIgnoredFile(clean)) keepers.push(clean);
+      continue;
+    }
+    if (throwawayIgnoredDir(wtPath, clean)) continue;
+    const stack = [clean];
+    while (stack.length) {
+      const rel = stack.pop();
+      let children;
+      try { children = fs.readdirSync(path.join(wtPath, rel), { withFileTypes: true }); } catch { return null; }
+      for (const child of children) {
+        walked += 1;
+        if (walked > IGNORED_WALK_LIMIT) return null;
+        const childRel = `${rel}/${child.name}`;
+        if (child.isDirectory()) {
+          if (!throwawayIgnoredDir(wtPath, childRel)) stack.push(childRel);
+        } else if (!throwawayIgnoredFile(childRel)) {
+          keepers.push(childRel);
+        }
+      }
+    }
+  }
+  return keepers;
+}
+
+// Why a copy holds work the snapshot cannot prove it saved, or '' when it
+// holds none: index entries told to hide their edits, conflicts, sparse
+// checkouts, and nested repositories other than a registered submodule that
+// sits clean at a commit its own origin already has.
+function unprovableReason(wtPath) {
+  const flags = runGit(['ls-files', '-v', '-z'], { cwd: wtPath, check: false });
+  if (flags.status !== 0) return 'could not read the index';
+  const hidden = String(flags.stdout || '').split('\0').filter(Boolean)
+    .filter((row) => /^[a-zS]/.test(row)).map((row) => row.slice(2));
+  if (hidden.length) return `index entries hide their edits (assume-unchanged or skip-worktree): ${hidden.slice(0, 3).join(', ')}`;
+  const conflicts = runGit(['ls-files', '-u'], { cwd: wtPath, check: false });
+  if (conflicts.status !== 0 || String(conflicts.stdout || '').trim()) return 'unresolved merge conflicts';
+  const sparse = runGit(['config', '--bool', 'core.sparseCheckout'], { cwd: wtPath, check: false });
+  if (String(sparse.stdout || '').trim() === 'true') return 'sparse checkout';
+  // git lists an untracked folder that is its own repository as `name/`;
+  // committing it would save only a pointer, not its files or commits.
+  const untracked = runGit(['ls-files', '--others', '--exclude-standard', '-z'], { cwd: wtPath, check: false });
+  if (untracked.status !== 0) return 'could not list untracked files';
+  const nested = String(untracked.stdout || '').split('\0').filter((entry) => entry.endsWith('/'));
+  if (nested.length) return `nested git repository ${nested[0].replace(/\/$/, '')} is not saved by a commit`;
+  const listed = runGit(['ls-files', '-s', '-z'], { cwd: wtPath, check: false });
+  if (listed.status !== 0) return 'could not read the index';
+  const links = new Map();
+  for (const row of String(listed.stdout || '').split('\0').filter(Boolean)) {
+    const match = row.match(/^160000 ([0-9a-f]+) \d\t(.+)$/);
+    if (match) links.set(match[2], match[1]);
+  }
+  if (!links.size) return '';
+  const registered = runGit(['config', '--file', '.gitmodules', '--get-regexp', '^submodule\\..*\\.path$'], { cwd: wtPath, check: false });
+  const paths = new Set(String(registered.stdout || '').split('\n').map((line) => line.split(' ').slice(1).join(' ')).filter(Boolean));
+  for (const [link, oid] of links) {
+    if (!paths.has(link)) return `nested git repository ${link} is not a registered submodule`;
+    const dir = path.join(wtPath, link);
+    let entries = [];
+    try { entries = fs.readdirSync(dir); } catch {}
+    if (!entries.length) continue;
+    const head = runGit(['rev-parse', 'HEAD'], { cwd: dir, check: false });
+    const status = runGit(['status', '--porcelain', '--ignored=matching'], { cwd: dir, check: false });
+    const pushed = runGit(['branch', '-r', '--contains', oid], { cwd: dir, check: false });
+    if (head.status !== 0 || head.stdout.trim() !== oid || status.status !== 0 || String(status.stdout || '').trim()
+        || pushed.status !== 0 || !String(pushed.stdout || '').trim()) {
+      return `submodule ${link} has work not proven on its origin`;
+    }
+    // A clean status proves nothing if the submodule hides edits too.
+    const inner = unprovableReason(dir);
+    if (inner) return `submodule ${link}: ${inner}`;
+  }
+  return '';
+}
+
+// Settings that let git change bytes between disk and a commit. A content
+// filter (clean filters, LFS and the like) or the ident attribute (where
+// `$Id: any text $` hashes the same as `$Id$`) can hide local text even from
+// `git status`, so either keeps every copy, clean or dirty, on every removal
+// path. Line-ending and encoding conversion also keep a dirty copy, where the
+// rescue snapshot must match the disk byte for byte; on a clean copy they only
+// differ by reversible line endings or encoding, an accepted limit. A filter defined only in global config and named by no
+// attribute changes nothing and is allowed.
+const FILTER_ATTRIBUTE = /(?:^|\s)(?:filter|ident)(?:[=\s]|$)/m;
+const BYTE_CHANGING_ATTRIBUTE = /(?:^|\s)(?:filter|working-tree-encoding|eol|text|crlf|ident)(?:[=\s]|$)/m;
+
+function attributeFiles(wtPath) {
+  const files = [];
+  const listed = runGit(['ls-files', '--cached', '--others', '-z', '--', '.gitattributes', '*/.gitattributes'], { cwd: wtPath, check: false });
+  if (listed.status !== 0) return null;
+  for (const rel of String(listed.stdout || '').split('\0').filter(Boolean)) files.push(path.join(wtPath, rel));
+  const info = runGit(['rev-parse', '--path-format=absolute', '--git-path', 'info/attributes'], { cwd: wtPath, check: false });
+  if (info.status === 0 && info.stdout.trim()) files.push(info.stdout.trim());
+  const configured = runGit(['config', '--path', 'core.attributesFile'], { cwd: wtPath, check: false });
+  const fallback = path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'git', 'attributes');
+  files.push(configured.status === 0 && configured.stdout.trim() ? configured.stdout.trim() : fallback);
+  return files;
+}
+
+function byteChangingSetting(wtPath, { filtersOnly = false } = {}) {
+  const local = runGit(['config', '--local', '--get-regexp', '^filter\\.'], { cwd: wtPath, check: false });
+  if (String(local.stdout || '').trim()) return 'a content filter is set in this repo';
+  const worktreeScope = runGit(['config', '--worktree', '--get-regexp', '^filter\\.'], { cwd: wtPath, check: false });
+  if (String(worktreeScope.stdout || '').trim()) return 'a content filter is set in this copy';
+  for (const key of filtersOnly ? [] : ['core.autocrlf', 'core.eol']) {
+    const value = String(runGit(['config', key], { cwd: wtPath, check: false }).stdout || '').trim().toLowerCase();
+    if (value && value !== 'false' && !(key === 'core.eol' && value === 'native')) return `${key} converts line endings`;
+  }
+  const files = attributeFiles(wtPath);
+  if (!files) return 'could not list attribute files';
+  for (const file of files) {
+    let text = '';
+    try { text = fs.readFileSync(file, 'utf8'); } catch (error) {
+      if (error && error.code === 'ENOENT') continue;
+      return `could not read ${file}`;
+    }
+    const rows = text.split(/\r?\n/).filter((row) => !/^\s*(?:#|$)/.test(row));
+    const hit = rows.find((row) => (filtersOnly ? FILTER_ATTRIBUTE : BYTE_CHANGING_ATTRIBUTE).test(row));
+    if (hit) return `git attributes can change bytes on commit (${path.basename(file)}: ${hit.trim().slice(0, 60)})`;
+  }
+  return '';
+}
+
+function sizeKib(target) {
+  const measured = spawnSync('du', ['-sk', target], { encoding: 'utf8', timeout: 30000, killSignal: 'SIGKILL' });
+  const match = measured.status === 0 && !String(measured.stderr || '').trim() && String(measured.stdout || '').match(/^(\d+)\s/);
+  return match ? Number(match[1]) : 0;
+}
+
+function formatKib(kib) {
+  if (!Number.isFinite(kib) || kib <= 0) return 'an unknown amount';
+  if (kib >= 1024 * 1024) return `${(kib / (1024 * 1024)).toFixed(1)} GB`;
+  if (kib >= 1024) return `${Math.round(kib / 1024)} MB`;
+  return `${kib} KB`;
+}
+
+function worktreeEntry(root, wtPath) {
+  return listWorktrees(root).find((wt) => canonicalPath(wt.path) === canonicalPath(wtPath)) || null;
+}
+
+function remoteBranchOid(root, branch) {
+  const remote = runGit(['ls-remote', 'origin', `refs/heads/${branch}`], { cwd: root, check: false });
+  if (remote.status !== 0 || remote.error) return null;
+  const match = String(remote.stdout || '').match(/^([0-9a-f]{40,64})\s+refs\/heads\/(\S+)$/m);
+  return match && match[2] === branch ? match[1] : '';
+}
+
+// Where the copy's last commit is safe outside the copy: merged into the
+// branch it landed on, or sitting on the same branch at origin.
+function shippedWorkHome(root, { head, branch, landedOn }) {
+  if (landedOn) {
+    if (landedOn.startsWith('origin/')) refreshRemoteRef(root, landedOn);
+    if (runGit(['merge-base', '--is-ancestor', head, landedOn], { cwd: root, check: false }).status === 0) {
+      return baseBranchName(landedOn);
+    }
+  }
+  if (branch && remoteBranchOid(root, branch) === head) return `origin/${branch}`;
+  return '';
+}
+
+// Remove a copy right after ship lands or pushes it. Runs from the main
+// checkout, never from inside the copy. A copy with changes, files that cannot
+// come back, or another program inside it is kept and the reason returned.
+function removeShippedCopyNow({ root, primary, branch = '', landedOn = '', keep = false, env = process.env, atrisBin = ATRIS_BIN, activePaths = listActiveProcessPaths } = {}) {
+  if (keep) return { removed: false, reason: 'kept on request (--keep-copy)' };
+  if (env.ATRIS_WORKTREE_KEEP_AFTER_SHIP === '1') return { removed: false, reason: 'ATRIS_WORKTREE_KEEP_AFTER_SHIP=1' };
+  const copy = canonicalPath(root);
+  if (!primary || copy === canonicalPath(primary)) return { removed: false, reason: 'primary checkout', quiet: true };
+  if (!space.isAgentCopyPath(copy)) return { removed: false, reason: 'not an agent build copy', quiet: true };
+  if (space.isInside(atrisBin, copy)) return { removed: false, reason: 'this atris runs from inside the copy' };
+  const mainRoot = canonicalPath(primary);
+  const wt = worktreeEntry(mainRoot, copy);
+  if (!wt) return { removed: false, reason: 'not registered' };
+  if (wt.locked) return { removed: false, reason: 'locked' };
+  const counts = statusCounts(copy);
+  if (!counts) return { removed: false, reason: 'unreadable' };
+  if (counts.staged || counts.unstaged || counts.untracked) {
+    return { removed: false, reason: `it still has ${counts.staged + counts.unstaged + counts.untracked} unsaved changes` };
+  }
+  const keepers = ignoredFilesToKeep(copy);
+  if (!keepers) return { removed: false, reason: 'could not check the files git ignores', retry: true };
+  if (keepers.length) return { removed: false, reason: `it holds ignored files atris cannot rebuild: ${keepers.slice(0, 3).join(', ')}` };
+  const unprovable = byteChangingSetting(copy, { filtersOnly: true }) || unprovableReason(copy);
+  if (unprovable) return { removed: false, reason: unprovable };
+  const head = runGit(['rev-parse', 'HEAD'], { cwd: copy, check: false });
+  const headOid = head.status === 0 ? head.stdout.trim() : '';
+  if (!headOid) return { removed: false, reason: 'no commit' };
+  const home = shippedWorkHome(mainRoot, { head: headOid, branch, landedOn });
+  if (!home) return { removed: false, reason: 'could not confirm the work reached origin', retry: true };
+  // Step out first so this process is not one of the programs inside. The
+  // shell that ran ship still is, so a copy someone stands in waits for the
+  // delayed remover instead of vanishing under them.
+  if (space.isInside(process.cwd(), copy)) {
+    try { process.chdir(mainRoot); } catch { return { removed: false, reason: 'could not step out of the copy', retry: true }; }
+  }
+  const active = activePaths();
+  if (!Array.isArray(active)) return { removed: false, reason: 'could not list running programs', retry: true };
+  if (worktreeHasActiveProcess(copy, active)) return { removed: false, reason: 'a program is still working in it', retry: true };
+  const kib = sizeKib(copy);
+  const removed = runGit(['worktree', 'remove', copy], { cwd: mainRoot, check: false });
+  if (removed.status !== 0) return { removed: false, reason: `git refused: ${gitFailureDetail(removed) || 'remove failed'}`, retry: true };
+  recordWorktreeRemoval(mainRoot, { path: copy, branch, by: 'atris worktree ship', reason: 'shipped', saved_on: home, size_kib: kib });
+  return { removed: true, kib, home, path: copy };
+}
+
+// After a successful ship: remove the copy now, or hand a landed copy to the
+// delayed remover when something still runs inside it.
+function finishShippedCopy({ root, primary, branch, landedOn = '', keep = false, log = console.log, schedule = scheduleShippedCopyRemoval }) {
+  const result = removeShippedCopyNow({ root, primary, branch, landedOn, keep });
+  if (result.removed) {
+    log(`cleanup: removed this build copy and freed ${formatKib(result.kib)}; the work is safe on ${result.home}`);
+    return result;
+  }
+  if (result.retry && !keep) {
+    log(`cleanup: not yet (${result.reason})`);
+    announceShippedCopyRemoval(schedule({ root, primary, branch, base: landedOn }));
+    return result;
+  }
+  if (!result.quiet) log(`cleanup: kept this build copy (${result.reason})`);
+  return result;
+}
+
+// The delayed remover for a copy whose branch was pushed but not merged:
+// wait for quiet, then retry the same checks ship ran until the copy is free.
+function reapPushedCopy({
+  primary,
+  target,
+  branch = '',
+  settleMs = SHIP_SETTLE_MS,
+  pollMs = SHIP_REAP_POLL_MS,
+  giveUpMs = SHIP_REAP_GIVE_UP_MS,
+  sleep = sleepSync,
+  clock = Date.now,
+  remove = removeShippedCopyNow,
+} = {}) {
+  const startedAt = clock();
+  sleep(settleMs);
+  for (;;) {
+    const result = remove({ root: target, primary, branch });
+    if (result.removed) return { removed: true, reason: 'pushed' };
+    if (!result.retry || clock() - startedAt >= giveUpMs) return { removed: false, reason: result.reason };
+    sleep(pollMs);
+  }
+}
+
+// Snapshot a copy as two git trees through a throwaway copy of its index, so
+// the copy and its own index stay untouched: what is staged, and everything on
+// disk including untracked files. Keeping both means a staged version that
+// differs from the file on disk survives too.
+function snapshotTrees(wtPath) {
+  const realIndex = String(runGit(['rev-parse', '--path-format=absolute', '--git-path', 'index'], { cwd: wtPath, check: false }).stdout || '').trim();
+  const index = path.join(os.tmpdir(), `atris-rescue-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.index`);
+  const env = { ...process.env, GIT_INDEX_FILE: index };
+  const run = (args) => spawnSync('git', args, { cwd: wtPath, encoding: 'utf8', env, maxBuffer: COMMAND_MAX_BUFFER_BYTES, timeout: 120000, killSignal: 'SIGKILL' });
+  try {
+    if (realIndex && fs.existsSync(realIndex)) fs.copyFileSync(realIndex, index);
+    else if (run(['read-tree', 'HEAD']).status !== 0) return null;
+    const staged = run(['write-tree']);
+    if (staged.status !== 0) return null;
+    if (run(['add', '-A']).status !== 0) return null;
+    const disk = run(['write-tree']);
+    if (disk.status !== 0) return null;
+    return { staged: staged.stdout.trim(), disk: disk.stdout.trim() };
+  } finally {
+    try { fs.rmSync(index, { force: true }); } catch {}
+  }
+}
+
+function newestChangeMs(wtPath) {
+  let newest = lastCopyActivityMs(wtPath);
+  const status = runGit(['status', '--porcelain=v1', '-z', '--untracked-files=all'], { cwd: wtPath, check: false });
+  if (status.status !== 0) return newest;
+  const fields = String(status.stdout || '').split('\0');
+  for (let i = 0; i < fields.length; i += 1) {
+    const row = fields[i];
+    if (row.length < 4) continue;
+    if (row[0] === 'R' || row[0] === 'C') i += 1;
+    try { newest = Math.max(newest, fs.lstatSync(path.join(wtPath, row.slice(3))).mtimeMs); } catch {}
+  }
+  return newest;
+}
+
+function commitIdentityEnv(wtPath) {
+  const email = runGit(['config', 'user.email'], { cwd: wtPath, check: false });
+  const name = runGit(['config', 'user.name'], { cwd: wtPath, check: false });
+  const env = { ...process.env };
+  if (email.status !== 0 || !email.stdout.trim()) {
+    env.GIT_AUTHOR_EMAIL = '299057014+atris-builder[bot]@users.noreply.github.com';
+    env.GIT_COMMITTER_EMAIL = env.GIT_AUTHOR_EMAIL;
+  }
+  if (name.status !== 0 || !name.stdout.trim()) {
+    env.GIT_AUTHOR_NAME = 'atris worktree sweep';
+    env.GIT_COMMITTER_NAME = env.GIT_AUTHOR_NAME;
+  }
+  return env;
+}
+
+// Rescue of abandoned dirty copies. Off unless the sweep runs with --rescue;
+// the timer never passes it, and the default sweep only reports these copies.
+//
+// Guarantee: a dirty copy is removed only when every byte in it is proven
+// saved on origin or proven throwaway. The staged and on-disk versions are
+// committed onto a brand-new atris-rescue/<copy>-<time> branch, created only
+// if the name is free here and on origin, pushed, confirmed on origin, and
+// the copy is checked again before removal. No existing branch ever moves.
+// Anything unusual keeps the copy for a person, with the reason.
+//
+// Accepted limits, each of which keeps the copy instead of risking it:
+// - ignored files other than installs and caches beside their package file,
+//   or atris's own plumbing
+// - nested repositories other than a submodule clean at a pushed commit
+// - index flags that hide edits, conflicts, sparse checkouts
+// - content filters and the ident attribute (on every removal path, clean
+//   copies too), and for dirty copies line-ending or encoding conversion
+// - a push the remote or its hooks refuse
+// What it cannot see: a program that writes into the copy between the last
+// check and the removal without holding a file open or standing in it.
+//
+// Returns { kept } with a reason, { candidate } on a dry run, or { removed }.
+function rescueAbandonedCopy({ root, wt, wtPath, item, counts, apply, now, idleMs, rescueIdleMs, rescue = false, activeCwdsOverride, budget, by }) {
+  const dirty = Boolean(counts && (counts.staged || counts.unstaged || counts.untracked));
+  const baseReason = dirty ? 'dirty' : (wt.branch === 'detached' ? 'detached_unmerged' : 'unmerged');
+  const keep = (reason, extra = {}) => ({ kept: { ...item, reason, ...(dirty ? { staged: counts.staged, unstaged: counts.unstaged, untracked: counts.untracked } : {}), ...extra } });
+  const named = Boolean(wt.branch && wt.branch !== 'detached');
+  if (runGit(['remote', 'get-url', 'origin'], { cwd: root, check: false }).status !== 0) return keep(baseReason, { rescue: 'no origin to push to' });
+  const keepers = ignoredFilesToKeep(wtPath);
+  if (!keepers) return keep('ignored_scan_failed');
+  if (keepers.length) return keep('ignored_data', { files: keepers.slice(0, 5) });
+  const unprovable = byteChangingSetting(wtPath, { filtersOnly: !dirty }) || unprovableReason(wtPath);
+  if (unprovable) return keep('unprovable', { why: unprovable });
+  const headOid = String(runGit(['rev-parse', 'HEAD'], { cwd: wtPath, check: false }).stdout || '').trim();
+  if (!headOid) return keep('missing_head');
+  const ownRemote = named ? remoteBranchOid(root, wt.branch) : '';
+  if (ownRemote === null) return keep(baseReason, { rescue: 'origin unreachable' });
+  const alreadySaved = !dirty && named && ownRemote === headOid;
+  const idleFor = now - newestChangeMs(wtPath);
+  const limit = alreadySaved ? idleMs : rescueIdleMs;
+  const idleDays = Math.round((idleFor / DAY_MS) * 10) / 10;
+  if (idleFor < limit) return keep(baseReason, { idle_days: idleDays });
+  // Without --rescue the sweep only reports a stale copy that needs saving.
+  if (!alreadySaved && !rescue) return keep(dirty ? 'stale_dirty' : 'stale_unpushed', { idle_days: idleDays, next: 'atris worktree sweep --rescue' });
+  const kib = sizeKib(wtPath);
+  if (!kib || budget.count >= 20 || budget.kib + kib > 10 * 1024 * 1024) return keep('size_unknown_or_cleanup_limit');
+  const fileCount = dirty ? counts.staged + counts.unstaged + counts.untracked : 0;
+  const rescueBranch = alreadySaved ? wt.branch
+    : `atris-rescue/${slugify(path.basename(wtPath), 'copy', 60)}-${stamp(new Date(now))}-${Math.random().toString(16).slice(2, 6)}`;
+  const candidate = {
+    ...item,
+    reason: alreadySaved ? 'pushed_branch' : 'rescued_to_branch',
+    rescue_branch: rescueBranch,
+    changed_files: fileCount,
+    idle_days: idleDays,
+    size_kib: kib,
+  };
+  budget.count += 1;
+  budget.kib += kib;
+  if (!apply) return { candidate };
+
+  const headTree = String(runGit(['rev-parse', 'HEAD^{tree}'], { cwd: wtPath, check: false }).stdout || '').trim();
+  const trees = dirty ? snapshotTrees(wtPath) : null;
+  if (dirty && !trees) return keep(baseReason, { rescue: 'could not snapshot the changes' });
+  let commit = headOid;
+  if (dirty) {
+    const trailer = 'Co-authored-by: Atris <299057014+atris-builder[bot]@users.noreply.github.com>';
+    const note = `The sweep found ${path.basename(wtPath)} idle for ${idleDays} days with changes nobody committed. It saved them here before removing the copy. Nothing was reviewed or merged.`;
+    const identity = commitIdentityEnv(wtPath);
+    const commitTree = (tree, parent, title) => {
+      const made = spawnSync('git', ['commit-tree', tree, '-p', parent, '-m', [title, '', note, '', trailer].join('\n')], {
+        cwd: wtPath, encoding: 'utf8', env: identity, timeout: 30000, killSignal: 'SIGKILL',
+      });
+      return made.status === 0 ? made.stdout.trim() : '';
+    };
+    // Staged work first, then what was on disk on top, so neither version is lost.
+    if (trees.staged !== headTree) {
+      commit = commitTree(trees.staged, commit, 'Rescue staged work from an abandoned build copy');
+      if (!commit) return keep(baseReason, { rescue: 'commit of the staged work failed' });
+    }
+    if (trees.disk !== trees.staged) {
+      commit = commitTree(trees.disk, commit, `Rescue unsaved work from an abandoned build copy (${fileCount} changed files)`);
+      if (!commit) return keep(baseReason, { rescue: 'commit of the work on disk failed' });
+    }
+  }
+  if (!alreadySaved) {
+    // Fresh name only: refuse if origin or this repo already has it.
+    const taken = remoteBranchOid(root, rescueBranch);
+    if (taken !== '') return keep('rescue_push_failed', { rescue_branch: rescueBranch, error: taken === null ? 'origin unreachable' : 'rescue branch name already on origin' });
+    const zero = '0'.repeat(commit.length);
+    const created = runGit(['update-ref', `refs/heads/${rescueBranch}`, commit, zero], { cwd: root, check: false });
+    if (created.status !== 0) return keep('rescue_push_failed', { rescue_branch: rescueBranch, error: `could not create the rescue branch: ${gitFailureDetail(created)}` });
+    const pushed = runGit(['push', 'origin', `refs/heads/${rescueBranch}:refs/heads/${rescueBranch}`], { cwd: root, check: false });
+    if (remoteBranchOid(root, rescueBranch) !== commit) {
+      return keep('rescue_push_failed', { rescue_branch: rescueBranch, rescue_commit: commit, error: (gitFailureDetail(pushed) || 'origin does not show the pushed commit').slice(0, 300) });
+    }
+  }
+  const freshActive = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessPaths();
+  const fresh = worktreeEntry(root, wtPath);
+  const freshHead = String(runGit(['rev-parse', 'HEAD'], { cwd: wtPath, check: false }).stdout || '').trim();
+  const freshTrees = dirty ? snapshotTrees(wtPath) : null;
+  const freshKeepers = ignoredFilesToKeep(wtPath);
+  const freshCounts = statusCounts(wtPath);
+  if (!Array.isArray(freshActive) || worktreeHasActiveProcess(wtPath, freshActive)
+      || !fresh || fresh.locked || freshHead !== headOid
+      || (dirty && (!freshTrees || freshTrees.staged !== trees.staged || freshTrees.disk !== trees.disk))
+      || !freshKeepers || freshKeepers.length || unprovableReason(wtPath) || byteChangingSetting(wtPath, { filtersOnly: !dirty }) || !freshCounts
+      || Boolean(freshCounts.staged || freshCounts.unstaged || freshCounts.untracked) !== dirty) {
+    return keep('changed_or_active_during_verification', { rescue_branch: rescueBranch, rescue_commit: commit });
+  }
+  const removeArgs = dirty ? ['worktree', 'remove', '--force', wtPath] : ['worktree', 'remove', wtPath];
+  const removed = runGit(removeArgs, { cwd: root, check: false });
+  if (removed.status !== 0) {
+    return keep('remove_failed', { rescue_branch: rescueBranch, rescue_commit: commit, error: gitFailureDetail(removed) });
+  }
+  const originUrl = String(runGit(['remote', 'get-url', 'origin'], { cwd: root, check: false }).stdout || '').trim();
+  const rescueRecord = { branch: rescueBranch, commit, remote: originUrl, copy_branch: named ? wt.branch : null, changed_files: fileCount };
+  recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason, rescue: rescueRecord, size_kib: kib });
+  return { removed: { ...candidate, rescue_commit: commit } };
+}
+
 function cleanupWorktrees({
   root = repoRoot(),
   base: baseOverride = '',
@@ -1207,6 +1680,8 @@ function cleanupWorktrees({
   freshGraceMs = WORKTREE_REAP_GRACE_MS,
   now = Date.now(),
   cleanupBudget = null,
+  rescueIdleMs = 0,
+  rescue = false,
 } = {}) {
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
@@ -1219,6 +1694,8 @@ function cleanupWorktrees({
   const removed = [];
   const cacheCandidates = [];
   const cachePruned = [];
+  const rescued = [];
+  const rescueCandidates = [];
   const cacheBudget = cleanupBudget || { count: 0, kib: 0 };
   const scopePaths = Array.isArray(onlyPaths) ? onlyPaths.map(canonicalPath) : null;
   const inScope = (wtPath) => (!scopePaths || scopePaths.includes(canonicalPath(wtPath)))
@@ -1264,19 +1741,44 @@ function cleanupWorktrees({
       kept.push({ ...item, reason: 'missing_or_unreadable' });
       continue;
     }
+    const tryRescue = (dirtyCounts) => {
+      const outcome = rescueAbandonedCopy({
+        root, wt, wtPath, item, counts: dirtyCounts, apply, now, idleMs, rescueIdleMs, rescue, activeCwdsOverride, budget: cacheBudget, by,
+      });
+      if (outcome.removed) {
+        removed.push(outcome.removed);
+        rescued.push(outcome.removed);
+      } else if (outcome.candidate) {
+        candidates.push(outcome.candidate);
+        rescueCandidates.push(outcome.candidate);
+      } else {
+        if (outcome.kept.reason !== 'changed_or_active_during_verification') pruneCachesForKept(wtPath);
+        kept.push(outcome.kept);
+      }
+    };
     if (counts.staged || counts.unstaged || counts.untracked) {
+      if (rescueIdleMs > 0) {
+        tryRescue(counts);
+        continue;
+      }
       pruneCachesForKept(wtPath);
       kept.push({ ...item, reason: 'dirty', staged: counts.staged, unstaged: counts.unstaged, untracked: counts.untracked });
       continue;
     }
-    const ignored = runGit(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], { cwd: wt.path, check: false });
-    if (ignored.status !== 0 || ignored.error) {
+    const keepers = ignoredFilesToKeep(wt.path);
+    if (!keepers) {
       kept.push({ ...item, reason: 'ignored_scan_failed' });
       continue;
     }
-    if (ignored.stdout) {
+    if (keepers.length) {
       pruneCachesForKept(wtPath);
-      kept.push({ ...item, reason: 'ignored_data' });
+      kept.push({ ...item, reason: 'ignored_data', files: keepers.slice(0, 5) });
+      continue;
+    }
+    const unprovable = byteChangingSetting(wt.path, { filtersOnly: true }) || unprovableReason(wt.path);
+    if (unprovable) {
+      pruneCachesForKept(wtPath);
+      kept.push({ ...item, reason: 'unprovable', why: unprovable });
       continue;
     }
     if (!wt.head) {
@@ -1289,6 +1791,10 @@ function cleanupWorktrees({
       continue;
     }
     const merged = runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status === 0;
+    if (!merged && rescueIdleMs > 0) {
+      tryRescue(null);
+      continue;
+    }
     if (!merged) {
       pruneCachesForKept(wtPath);
       kept.push({ ...item, reason: wt.branch === 'detached' ? 'detached_unmerged' : 'unmerged' });
@@ -1326,14 +1832,14 @@ function cleanupWorktrees({
     if (!apply) continue;
     const freshActive = Array.isArray(activeCwdsOverride) ? activeCwds : listActiveProcessPaths();
     const freshCounts = statusCounts(wt.path);
-    const freshIgnored = runGit(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], { cwd: wt.path, check: false });
+    const freshKeepers = ignoredFilesToKeep(wt.path);
     const freshSize = spawnSync('du', ['-sk', wtPath], { encoding: 'utf8', timeout: 30000, killSignal: 'SIGKILL' });
     const freshMatch = freshSize.status === 0 && !String(freshSize.stderr || '').trim() && String(freshSize.stdout || '').match(/^(\d+)\s/);
     const gitdir = runGit(['rev-parse', '--absolute-git-dir'], { cwd: wtPath, check: false });
     const freshHead = runGit(['rev-parse', 'HEAD'], { cwd: wtPath, check: false });
     if (!Array.isArray(freshActive) || worktreeHasActiveProcess(wtPath, freshActive)
         || !freshCounts || freshCounts.staged || freshCounts.unstaged || freshCounts.untracked
-        || freshIgnored.status !== 0 || freshIgnored.stdout || !freshMatch || Number(freshMatch[1]) !== kib
+        || !freshKeepers || freshKeepers.length || unprovableReason(wt.path) || byteChangingSetting(wt.path, { filtersOnly: true }) || !freshMatch || Number(freshMatch[1]) !== kib
         || gitdir.status !== 0 || !gitdir.stdout.trim() || fs.existsSync(path.join(gitdir.stdout.trim(), 'locked'))
         || freshHead.status !== 0 || String(freshHead.stdout || '').trim() !== wt.head
         || runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status !== 0
@@ -1351,17 +1857,17 @@ function cleanupWorktrees({
     }
   }
 
-  return { apply, base, candidates, removed, kept, cacheCandidates, cachePruned };
+  return { apply, base, candidates, removed, kept, cacheCandidates, cachePruned, rescued, rescueCandidates };
 }
 
 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', cleanupBudget = null } = {}) {
+function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, rescueIdleMs = RESCUE_IDLE_MS, rescue = false, 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: [] };
+  const report = { workspace: root, apply, rescue, idle_ms: idleMs, rescue_idle_ms: rescueIdleMs, before, after: before, repos: [] };
   const scan = Array.isArray(activeCwds) ? activeCwds.map(canonicalPath) : listActiveProcessPaths();
   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);
@@ -1375,12 +1881,14 @@ function sweepWorkspace({ workspace, apply = false, idleMs = SWEEP_IDLE_MS, acti
         continue;
       }
       const shared = Array.isArray(activeCwds) || !apply ? scan : undefined;
-      const result = cleanupWorktrees({ root: repo.root, base, apply, activeCwds: shared, by, onlyUnder: scope, idleMs, cleanupBudget });
+      const result = cleanupWorktrees({ root: repo.root, base, apply, activeCwds: shared, by, onlyUnder: scope, idleMs, rescueIdleMs, rescue, cleanupBudget });
       report.repos.push({
         ...entry,
         base: result.base,
         removed: result.removed,
         candidates: result.candidates,
+        rescued: result.rescued,
+        rescueCandidates: result.rescueCandidates,
         cachePruned: result.cachePruned,
         cacheCandidates: result.cacheCandidates,
         kept: result.kept.filter((item) => !SWEEP_HIDDEN_KEPT.has(item.reason)),
@@ -1400,7 +1908,7 @@ const SWEEP_KEPT_LABELS = {
   dirty: 'with changes',
   unmerged: 'not merged',
   detached_unmerged: 'not merged',
-  ignored_data: 'holding files git ignores (kept for review)',
+  ignored_data: 'holding ignored files that cannot be rebuilt (kept for review)',
   ignored_scan_failed: 'unreadable',
   fresh_worktree_grace: 'new',
   recent_activity: 'used recently',
@@ -1414,6 +1922,10 @@ const SWEEP_KEPT_LABELS = {
   path_not_canonical: 'behind a link',
   size_unknown_or_cleanup_limit: 'over the per-run limit',
   changed_or_active_during_verification: 'changed during the check',
+  rescue_push_failed: 'push of its saved work failed',
+  unprovable: 'holding work atris cannot prove it saved',
+  stale_dirty: 'stale with unsaved changes (save with --rescue)',
+  stale_unpushed: 'stale with commits not on origin (save with --rescue)',
 };
 
 function plural(count, one, many) {
@@ -1448,10 +1960,13 @@ function sweepSchedulePlan({ workspace, everyHours = SWEEP_EVERY_HOURS, homeDir
 
 module.exports = {
   ATRIS_BIN,
+  reapPushedCopy,
+  RESCUE_IDLE_MS,
+  finishShippedCopy,
+  formatKib,
   SWEEP_IDLE_MS,
   SWEEP_EVERY_HOURS,
   SWEEP_KEPT_LABELS,
-  announceShippedCopyRemoval,
   assertOneLapProofTree,
   baseBranchName,
   branchName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.82.1",
+  "version": "3.82.2",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof. project memory your coding agents share across sessions.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",