atris 3.74.25 → 3.74.26

package/commands/gm.js

@@ -1895,6 +1895,8 @@ function wakeableMember(args) {
 }
 
 async function gmCommand(...args) {
+  const leaseDb = require('../lib/task-db');
+  try { leaseDb.sweepExpiredLeases(); } catch (_) { /* Existing views report unreadable databases. */ }
   // the walk has its own help
   if (positional(args)[0] === 'walk') {
     const at = args.indexOf('walk');

package/commands/rating.js

@@ -46,7 +46,15 @@ function readHere(deps = {}) {
   const team = new Map(((lineup && lineup.ok && lineup.team) || []).map((row) => [String(row.member || '').toLowerCase(), row]));
   const members = rows.map((row) => {
     const seat = team.get(row.name.toLowerCase()) || {};
-    return { member: row.name, ovr: row.ovr, landed: row.landed, finished: row.finished, job: seat.job || null, model: seat.model || null };
+    const reasons = new Map();
+    for (const play of played.outcomes || []) {
+      if (play.member === row.name && ['dropped', 'sent_back', 'abandoned'].includes(play.kind) && play.reason) {
+        reasons.set(play.reason, (reasons.get(play.reason) || 0) + 1);
+      }
+    }
+    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, 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;
@@ -104,12 +112,18 @@ function renderMember(m, card) {
     `  landed ${m.landed} of ${m.finished} finished jobs in the last 30 days`,
   ];
   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:');
+    for (const item of m.miss_reasons) lines.push(`  ${item.count}: ${item.reason}`);
+  }
   if (card && m.job === 'build') lines.push(`  its engine, ${card.label}, is ${rated(card.ovr)} in the combine: atris rating ${card.label.split(' ')[0]}`);
   lines.push(`  every play: atris gm card ${m.member}`);
   return lines.join('\n');
 }
 
 function ratingCommand(args = [], deps = {}) {
+  const taskDb = require('../lib/task-db');
+  taskDb.sweepExpiredLeases();
   const write = deps.write || ((text) => process.stdout.write(text));
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || args[0] === 'help') {
     write(`${USAGE}\n`);

package/commands/task.js

@@ -208,6 +208,7 @@ atris task - durable local task state (SQLite, gitignored)
   atris task auto-accept-certified --dry-run [--strict-verify] [--all] [--limit <n>]
                                            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 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
 
@@ -6252,7 +6253,10 @@ function cmdClaim(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
   const taskId = requireTaskId(taskDb, db, id, 'atris task claim');
-  const result = taskDb.claimTask(db, { id: taskId, claimedBy: String(owner) });
+  const leaseMinutes = flag(args, '--lease-minutes');
+  const leasePid = flag(args, '--lease-pid');
+  if (leaseMinutes != null && (!Number.isFinite(Number(leaseMinutes)) || Number(leaseMinutes) <= 0 || !Number.isInteger(Number(leasePid)) || Number(leasePid) <= 0)) throw new Error('invalid claim lease');
+  const result = taskDb.claimTask(db, { id: taskId, claimedBy: String(owner), ...(leaseMinutes == null ? {} : { leaseMinutes: Number(leaseMinutes), leasePid: Number(leasePid) }) });
   if (result.claimed) {
     const { projection, outPath } = writeDefaultProjection(taskDb, db);
     if (wantsJson(args)) {
@@ -10801,11 +10805,23 @@ function evaluateSweepAutoAccept(task, root, includeProtected = false) {
 
 function cmdSweep(args) {
   if (!hasFlag(args, '--auto-accept')) {
-    failTask(
-      'atris task sweep',
-      'missing_auto_accept',
-      'atris task sweep currently requires --auto-accept for the explicit verified accept policy',
-    );
+    const taskDb = getTaskDb();
+    const staleRaw = flag(args, '--stale-days');
+    if (staleRaw === true || (staleRaw != null && (!Number.isFinite(Number(staleRaw)) || Number(staleRaw) < 0))) throw new Error('stale days must be a nonnegative number');
+    const claimer = flag(args, '--claimer');
+    if (claimer === true) throw new Error('claimer requires a name');
+    const dryRun = hasFlag(args, '--dry-run');
+    const options = { staleDays: staleRaw == null ? undefined : Number(staleRaw), claimer };
+    const tasks = dryRun ? taskDb.previewExpiredLeases(options) : taskDb.expireLeases(taskDb.open(), options);
+    const groups = {};
+    for (const task of tasks) (groups[task.claimed_by] ||= []).push(task);
+    if (wantsJson(args)) printJson({ dry_run: dryRun, groups, tasks });
+    else if (!tasks.length) console.log(dryRun ? 'no claims would be released' : 'no claims released');
+    else for (const [name, entries] of Object.entries(groups)) {
+      console.log(`${name}: ${entries.length} ${dryRun ? 'would be released' : 'released'}`);
+      for (const entry of entries) console.log(`  ${entry.title}: ${entry.reason}`);
+    }
+    return;
   }
   // Sweep has no dry-run implementation: every successful invocation can
   // write accepts, even when an unrecognized --dry-run flag is supplied.
@@ -13076,6 +13092,11 @@ function cmdServe(args) {
 
 async function runTaskCommand(args) {
   const raw = args || [];
+  // A dry run must not mutate even already-expired leases.
+  if (!raw.includes('--dry-run') && !(raw[0] === 'sweep' && !raw.includes('--auto-accept'))) {
+    const taskDb = getTaskDb();
+    taskDb.sweepExpiredLeases();
+  }
   if (raw.includes('--help') || raw.includes('-h')) return help();
   const first = raw[0];
   if (!first) return cmdFirstMinute();
@@ -13273,7 +13294,7 @@ async function run(args) {
     return;
   }
   const result = await runTaskCommand(raw);
-  const skipsRender = sub === 'clear-done' && hasFlag(raw, '--dry-run');
+  const skipsRender = hasFlag(raw, '--dry-run');
   if (MUTATING_TASK_COMMANDS.has(sub) && !skipsRender) autoRenderTodoFromDb();
   return result;
 }

package/commands/worktree.js

@@ -1201,7 +1201,6 @@ const PROTECTED_BRANCHES = new Set(['main', 'master']);
 // (zero commits yet), so without a grace window the janitor reaps it while
 // the engine that requested it is still booting inside.
 const WORKTREE_REAP_GRACE_MS = 60 * 60 * 1000;
-const COMPLETED_UNMERGED_REAP_MS = WORKTREE_REAP_GRACE_MS;
 const GENERATED_WORKTREE_CACHE_DIRS = [
   '.derivedData',
   '.next',
@@ -1218,15 +1217,6 @@ function worktreeWithinReapGrace(worktreePath, now = Date.now()) {
   }
 }
 
-function completedAgentOutputAgeMs(worktreePath, now = Date.now()) {
-  try {
-    const output = path.join(worktreePath, '.codex-last-message.txt');
-    return now - fs.statSync(output).mtimeMs;
-  } catch {
-    return null;
-  }
-}
-
 function canonicalPath(value) {
   try {
     return fs.realpathSync(value);
@@ -1237,17 +1227,20 @@ function canonicalPath(value) {
 
 // null means the scan failed: we cannot tell who is inside, so callers keep
 // every folder. An empty list would read as "nobody is here" and delete.
-function listActiveProcessCwds() {
-  const result = spawnSync('lsof', ['-n', '-a', '-d', 'cwd', '-F', 'n'], {
+function listActiveProcessFiles() {
+  const result = spawnSync('lsof', ['-n', '-F', 'n'], {
     encoding: 'utf8',
     maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+    timeout: 20000,
+    killSignal: 'SIGKILL',
   });
-  if (result.error || result.status !== 0) return null;
-  return String(result.stdout || '')
+  if (result.error || result.status !== 0 || String(result.stderr || '').trim()) return null;
+  const paths = String(result.stdout || '')
     .split(/\r?\n/)
-    .filter((line) => line.startsWith('n'))
+    .filter((line) => line.startsWith('n/'))
     .map((line) => canonicalPath(line.slice(1)))
     .filter(Boolean);
+  return paths.length ? paths : null;
 }
 
 // Absolute paths named on each program's command line, including flag values
@@ -1274,17 +1267,20 @@ function listActiveProcessArgPaths() {
   const result = spawnSync('ps', ['-axww', '-o', 'args='], {
     encoding: 'utf8',
     maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+    timeout: 5000,
+    killSignal: 'SIGKILL',
   });
-  if (result.error || result.status !== 0) return [];
+  if (result.error || result.status !== 0) return null;
   return parseProcessArgPaths(result.stdout);
 }
 
-// Everything a running program is anchored to: its current folder plus any
-// script path on its command line.
+// Open files and working folders, plus script paths on command lines.
 function listActiveProcessPaths() {
-  const cwds = listActiveProcessCwds();
-  if (!Array.isArray(cwds)) return cwds;
-  return cwds.concat(listActiveProcessArgPaths());
+  const files = listActiveProcessFiles();
+  if (!Array.isArray(files)) return null;
+  const args = listActiveProcessArgPaths();
+  if (!Array.isArray(args)) return null;
+  return files.concat(args);
 }
 
 function worktreeHasActiveProcess(worktreePath, activeCwds) {
@@ -1311,7 +1307,44 @@ function recordWorktreeRemoval(root, { path: removedPath, branch = '', by, reaso
   } catch {}
 }
 
-function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
+// Only webpack's disposable pack files have a sufficiently narrow contract
+// for unattended cleanup. Unknown files or links turn the folder into review.
+function webpackCacheSnapshot(worktreePath) {
+  try {
+    const root = fs.realpathSync(worktreePath);
+    let current = root;
+    for (const part of ['.next', 'cache', 'webpack']) {
+      current = path.join(current, part);
+      const stat = fs.lstatSync(current);
+      if (!stat.isDirectory() || stat.isSymbolicLink()) return null;
+    }
+    if (fs.realpathSync(current) !== current) return null;
+    const entries = [];
+    function walk(dir) {
+      for (const name of fs.readdirSync(dir).sort()) {
+        const file = path.join(dir, name);
+        const stat = fs.lstatSync(file);
+        if (stat.isSymbolicLink()) return false;
+        if (stat.isDirectory()) {
+          entries.push([file, 'd', stat.ino, stat.mtimeMs]);
+          if (!walk(file)) return false;
+        } else if (stat.isFile() && /^(?:index|\d+)\.pack(?:\.gz|\.old)?$/.test(name)) {
+          entries.push([file, 'f', stat.ino, stat.size, stat.mtimeMs]);
+        } else return false;
+      }
+      return true;
+    }
+    if (!walk(current)) return null;
+    const size = spawnSync('du', ['-sk', current], { encoding: 'utf8', timeout: 5000, killSignal: 'SIGKILL' });
+    const match = size.status === 0 && String(size.stdout || '').match(/^(\d+)\s/);
+    if (!match) return null;
+    return { path: current, kib: Number(match[1]), fingerprint: JSON.stringify(entries) };
+  } catch {
+    return null;
+  }
+}
+
+function pruneGeneratedWorktreeCaches(worktreePath, { apply = false, budget } = {}) {
   const candidates = [];
   const pruned = [];
   for (const relative of GENERATED_WORKTREE_CACHE_DIRS) {
@@ -1319,34 +1352,70 @@ function pruneGeneratedWorktreeCaches(worktreePath, { apply = false } = {}) {
     if (!fs.existsSync(target)) continue;
     const ignored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
     if (ignored.status !== 0) continue;
-    const item = { worktree: worktreePath, path: target, relative };
+    const item = { worktree: worktreePath, path: target, relative, reason: 'manual_review_required' };
     candidates.push(item);
-    if (!apply) continue;
-    try {
-      fs.rmSync(target, { recursive: true, force: true });
-      pruned.push(item);
-    } catch (error) {
-      item.error = String((error && error.message) || error);
+  }
+  const relative = '.next/cache/webpack';
+  const ignored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
+  const snapshot = ignored.status === 0 ? webpackCacheSnapshot(worktreePath) : null;
+  if (snapshot) {
+    const item = { worktree: worktreePath, path: snapshot.path, relative, kib: snapshot.kib, reason: 'generated_webpack_cache' };
+    candidates.push(item);
+    if (apply && budget && budget.count < 20 && budget.kib + snapshot.kib <= 10 * 1024 * 1024) {
+      const active = listActiveProcessPaths();
+      const fresh = webpackCacheSnapshot(worktreePath);
+      const stillIgnored = runGit(['check-ignore', '-q', '--', relative], { cwd: worktreePath, check: false });
+      if (Array.isArray(active) && !worktreeHasActiveProcess(worktreePath, active)
+          && stillIgnored.status === 0 && fresh && fresh.path === snapshot.path
+          && fresh.kib === snapshot.kib && fresh.fingerprint === snapshot.fingerprint) {
+        try {
+          fs.rmSync(snapshot.path, { recursive: true });
+          budget.count += 1;
+          budget.kib += snapshot.kib;
+          pruned.push(item);
+        } catch (error) {
+          item.error = String((error && error.message) || error);
+        }
+      }
     }
   }
   return { candidates, pruned };
 }
 
+function originBaseIsCurrent(root, base) {
+  const prefix = base.startsWith('origin/') ? 'origin/'
+    : base.startsWith('refs/remotes/origin/') ? 'refs/remotes/origin/' : '';
+  if (!prefix) {
+    if (base === 'HEAD') {
+      const branch = runGit(['symbolic-ref', '--short', 'HEAD'], { cwd: root, check: false });
+      return branch.status === 0 && PROTECTED_BRANCHES.has(branch.stdout.trim());
+    }
+    return PROTECTED_BRANCHES.has(base.replace(/^refs\/heads\//, ''));
+  }
+  const branch = base.slice(prefix.length);
+  const local = runGit(['rev-parse', '--verify', base], { cwd: root, check: false });
+  const remote = runGit(['ls-remote', '--exit-code', 'origin', `refs/heads/${branch}`], { cwd: root, check: false, timeout: 5000 });
+  const match = String(remote.stdout || '').match(/^([a-f0-9]{40,64})\s+(refs\/heads\/[^\r\n]+)$/m);
+  return local.status === 0 && remote.status === 0 && Boolean(match)
+    && match[2] === `refs/heads/${branch}` && local.stdout.trim() === match[1];
+}
+
 function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply = false, activeCwds: activeCwdsOverride, by = 'atris worktree cleanup' } = {}) {
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
   const current = path.resolve(root);
   const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessPaths();
   const base = normalizeTargetRef(root, baseOverride || defaultShipTarget(root));
-  refreshRemoteRef(root, base);
+  const refreshError = refreshRemoteRef(root, base);
   const candidates = [];
   const kept = [];
   const removed = [];
   const cacheCandidates = [];
   const cachePruned = [];
+  const cacheBudget = { count: 0, kib: 0 };
   const pruneCachesForKept = (wtPath) => {
     if (worktreeWithinReapGrace(wtPath)) return;
-    const caches = pruneGeneratedWorktreeCaches(wtPath, { apply });
+    const caches = pruneGeneratedWorktreeCaches(wtPath, { apply, budget: cacheBudget });
     cacheCandidates.push(...caches.candidates);
     cachePruned.push(...caches.pruned);
   };
@@ -1374,9 +1443,8 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       kept.push({ ...item, reason: activeCwds ? 'active_process' : 'process_scan_failed' });
       continue;
     }
-    const rawCounts = statusCounts(wt.path);
-    const counts = statusCounts(wt.path, { ignoreAny: isConductorArtifact });
-    if (!rawCounts || !counts) {
+    const counts = statusCounts(wt.path);
+    if (!counts) {
       kept.push({ ...item, reason: 'missing_or_unreadable' });
       continue;
     }
@@ -1385,58 +1453,78 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       kept.push({ ...item, reason: 'dirty', staged: counts.staged, unstaged: counts.unstaged, untracked: counts.untracked });
       continue;
     }
+    // Git removes ignored files along with a worktree. They may include local
+    // state, credentials, or user data, so a clean status is not enough proof.
+    const ignored = runGit(['ls-files', '--others', '--ignored', '--exclude-standard', '--directory', '-z'], { cwd: wt.path, check: false });
+    if (ignored.status !== 0 || ignored.error) {
+      kept.push({ ...item, reason: 'ignored_scan_failed' });
+      continue;
+    }
+    if (ignored.stdout) {
+      pruneCachesForKept(wtPath);
+      kept.push({ ...item, reason: 'ignored_data' });
+      continue;
+    }
     if (!wt.head) {
       pruneCachesForKept(wtPath);
       kept.push({ ...item, reason: 'missing_head' });
       continue;
     }
-    const artifactOnlyDirty = Boolean(
-      (rawCounts.staged || rawCounts.unstaged || rawCounts.untracked)
-      && !(counts.staged || counts.unstaged || counts.untracked)
-    );
+    if (refreshError) {
+      kept.push({ ...item, reason: 'base_refresh_failed' });
+      continue;
+    }
     const merged = runGit(['merge-base', '--is-ancestor', wt.head, base], { cwd: root, check: false }).status === 0;
     if (!merged) {
-      const completedAgeMs = completedAgentOutputAgeMs(wtPath);
-      if (completedAgeMs === null || completedAgeMs < COMPLETED_UNMERGED_REAP_MS) {
-        pruneCachesForKept(wtPath);
-        kept.push({
-          ...item,
-          reason: completedAgeMs === null ? 'unmerged' : 'completed_unmerged_retention',
-          ...(completedAgeMs === null ? {} : { retention_hours: 1 }),
-        });
-        continue;
-      }
-      const candidate = {
-        ...item,
-        reason: 'completed_unmerged_checkout_expired',
-        branch_preserved: true,
-        artifact_only_dirty: artifactOnlyDirty,
-      };
-      candidates.push(candidate);
-      if (!apply) continue;
-      const removeArgs = ['worktree', 'remove'];
-      if (artifactOnlyDirty) removeArgs.push('--force');
-      removeArgs.push(wt.path);
-      const removedResult = runGit(removeArgs, { cwd: root, check: false });
-      if (removedResult.status === 0) {
-        removed.push(candidate);
-        recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason });
-      } else {
-        kept.push({ ...item, reason: 'remove_failed', error: (removedResult.stderr || removedResult.stdout || '').trim() });
-      }
+      pruneCachesForKept(wtPath);
+      kept.push({ ...item, reason: wt.branch === 'detached' ? 'detached_unmerged' : 'unmerged' });
       continue;
     }
     if (worktreeWithinReapGrace(wtPath)) {
       kept.push({ ...item, reason: 'fresh_worktree_grace' });
       continue;
     }
-    const candidate = { ...item, reason: 'merged_into_base', artifact_only_dirty: artifactOnlyDirty };
+    if (!originBaseIsCurrent(root, base)) {
+      kept.push({ ...item, reason: 'base_unverified' });
+      continue;
+    }
+    let real;
+    try { real = fs.realpathSync(wtPath); } catch { real = ''; }
+    if (!real || real !== wtPath) {
+      kept.push({ ...item, reason: 'path_not_canonical' });
+      continue;
+    }
+    const measured = spawnSync('du', ['-sk', wtPath], { encoding: 'utf8', timeout: 30000, killSignal: 'SIGKILL' });
+    const sizeMatch = measured.status === 0 && !String(measured.stderr || '').trim() && String(measured.stdout || '').match(/^(\d+)\s/);
+    const kib = sizeMatch ? Number(sizeMatch[1]) : 0;
+    if (!kib || cacheBudget.count >= 20 || cacheBudget.kib + kib > 10 * 1024 * 1024) {
+      kept.push({ ...item, reason: 'size_unknown_or_cleanup_limit' });
+      continue;
+    }
+    const candidate = { ...item, reason: 'merged_into_base', size_kib: kib };
     candidates.push(candidate);
+    cacheBudget.count += 1;
+    cacheBudget.kib += kib;
     if (!apply) continue;
-    const removeArgs = ['worktree', 'remove'];
-    if (artifactOnlyDirty) removeArgs.push('--force');
-    removeArgs.push(wt.path);
-    const removedResult = runGit(removeArgs, { cwd: root, check: false });
+    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 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
+        || 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
+        || !originBaseIsCurrent(root, base)
+        || canonicalPath(wtPath) !== wtPath) {
+      kept.push({ ...item, reason: 'changed_or_active_during_verification' });
+      continue;
+    }
+    const removedResult = runGit(['worktree', 'remove', wt.path], { cwd: root, check: false });
     if (removedResult.status === 0) {
       removed.push(candidate);
       recordWorktreeRemoval(root, { path: wt.path, branch: wt.branch, by, reason: candidate.reason });
@@ -1465,10 +1553,13 @@ function cleanup(args) {
   for (const item of result.apply ? result.removed : result.candidates) {
     console.log(`${action}: ${item.path} branch=${item.branch} reason=${item.reason}`);
   }
-  const cacheAction = result.apply ? 'cache_pruned' : 'cache_candidate';
-  console.log(`${cacheAction}s: ${result.apply ? result.cachePruned.length : result.cacheCandidates.length}`);
-  for (const item of result.apply ? result.cachePruned : result.cacheCandidates) {
-    console.log(`${cacheAction}: ${item.path}`);
+  const review = result.cacheCandidates.filter((item) => item.reason === 'manual_review_required');
+  const safe = result.apply ? result.cachePruned : result.cacheCandidates.filter((item) => item.reason === 'generated_webpack_cache');
+  console.log(`cache ${result.apply ? 'removed' : 'candidate'}s: ${safe.length}`);
+  for (const item of safe) console.log(`cache: ${item.path} size_kib=${item.kib}`);
+  console.log(`cache review needed: ${review.length}`);
+  for (const item of review) {
+    console.log(`review: ${item.path} reason=${item.reason}`);
   }
   console.log(`kept: ${result.kept.length}`);
   if (!result.apply && result.candidates.length) console.log('next: atris worktree cleanup --apply');
@@ -1524,7 +1615,7 @@ function help() {
   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 ignored build caches');
+  console.log('  atris worktree cleanup [--apply] [--json] [--base origin/master]  reap completed checkouts and verified webpack caches');
 }
 
 function worktreeCommand(args = []) {

package/lib/fleet.js

@@ -3208,14 +3208,27 @@ async function runFleetFlight({
   // when the operator explicitly wants launcher-HEAD.
   const startBaseArgs = ['--base', landTarget];
   const prepared = [];
+  const leaseDb = require('./task-db');
+  const leaseConnection = leaseDb.open();
+  const leased = new Map();
+  const leaseTimer = setInterval(() => {
+    for (const [id, holder] of leased) leaseDb.renewLease(leaseConnection, { id, holder, pid: process.pid });
+  }, 5 * 60000);
+  leaseTimer.unref();
+  try {
   for (const entry of staffed) {
-    const claimed = cli(['task', 'claim', String(entry.task.display_id), '--as', `fleet-${entry.engine}`]);
+    const claimed = cli(['task', 'claim', String(entry.task.display_id), '--as', `fleet-${entry.engine}`, '--lease-minutes', '60', '--lease-pid', String(process.pid)]);
     if (!claimed || claimed.status !== 0) {
       const detail = String(claimed && (claimed.stderr || claimed.stdout) || 'claim failed').trim().slice(0, 300);
       flight.paused.push({ task: entry.task.display_id, engine: entry.engine, stage: 'claim', detail });
       log(`    ${entry.engine.padEnd(8)} ⏸ paused ${entry.task.display_id} at claim${detail ? `, ${detail}` : ''}`);
       continue;
     }
+    const leaseId = entry.task.id || entry.task.display_id;
+    const holder = `fleet-${entry.engine}`;
+    const leaseSet = leaseDb.setLease(leaseConnection, { id: leaseId, holder });
+    if (!leaseSet && (!ownCli || leaseDb.getTask(leaseConnection, leaseId))) throw new Error('could not set claim lease');
+    if (leaseSet) leased.set(leaseId, holder);
     const started = cli(['worktree', 'start', '--agent', entry.engine, '--task', `fleet-${String(entry.task.display_id).toLowerCase()}`, ...startBaseArgs]);
     const wt = (started.stdout.match(/next: cd (.+)/) || [])[1];
     if (!wt) {
@@ -3340,6 +3353,13 @@ async function runFleetFlight({
   log(`  flight over: ${flight.landed.length} landed, ${flight.paused.length} paused · receipt: ${path.relative(root, flight.receipt)}`);
   log('');
   return flight;
+  } finally {
+    clearInterval(leaseTimer);
+    for (const [id, holder] of leased) {
+      const row = leaseDb.getTask(leaseConnection, id);
+      if (row && row.status !== 'claimed') leaseDb.clearLease(leaseConnection, { id, holder });
+    }
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -3474,6 +3494,9 @@ async function runDispatchFlight({
   }
 
   const cli = ownCli || defaultOwnCli(root);
+  const leaseDb = require('./task-db');
+  const leaseConnection = leaseDb.open();
+  try { leaseDb.expireLeases(leaseConnection); } catch (err) { if (process.env.ATRIS_DEBUG) process.stderr.write(`lease sweep failed: ${String(err?.message ?? err).replace(/[\r\n]+/g, ' ')}\n`); }
   // Cut worktrees from, and check self-landing against, the workspace's real
   // protected branch, not a hard-coded origin/master (CLI-1298).
   const localBase = reviewOnly ? '' : localDispatchBase(root);
@@ -3517,6 +3540,12 @@ async function runDispatchFlight({
   // default so rebase-before-ship never replays a launcher feature branch.
   const startBaseArgs = landTarget ? ['--base', landTarget] : [];
   const prepared = [];
+  const leasedIds = new Set();
+  const leaseTimer = setInterval(() => {
+    for (const id of leasedIds) leaseDb.renewLease(leaseConnection, { id, holder: taskActor, pid: process.pid });
+  }, 5 * 60000);
+  leaseTimer.unref();
+  try {
   for (const taskId of ids) {
     const task = readTaskById(cli, taskId);
     if (!task) {
@@ -3524,7 +3553,7 @@ async function runDispatchFlight({
       log(`    ✗ ${taskId} not found`);
       continue;
     }
-    const claimed = cli(['task', 'claim', taskId, '--as', taskActor]);
+    const claimed = cli(['task', 'claim', taskId, '--as', taskActor, '--lease-minutes', '60', '--lease-pid', String(process.pid)]);
     if (!claimed || claimed.status !== 0) {
       const detail = String(claimed && (claimed.stderr || claimed.stdout) || 'claim failed').trim().slice(0, 300);
       flight.paused.push({ task: taskId, stage: 'claim', detail });
@@ -3532,6 +3561,10 @@ async function runDispatchFlight({
       continue;
     }
     try {
+      const leaseId = task.id || taskId;
+      const leased = leaseDb.setLease(leaseConnection, { id: leaseId, holder: taskActor });
+      if (!leased && (!ownCli || leaseDb.getTask(leaseConnection, leaseId))) throw new Error('could not set claim lease');
+      if (leased) leasedIds.add(leaseId);
       let landingWorktreePath = '';
       let remoteBoundary = null;
       if (enforceRemoteBoundary) {
@@ -4212,4 +4245,11 @@ async function runDispatchFlight({
   log(`  dispatch over: ${completedLabel}, ${flight.paused.length} paused - receipt: ${path.relative(root, flight.receipt)}`);
   log('');
   return flight;
+  } finally {
+    clearInterval(leaseTimer);
+    for (const id of leasedIds) {
+      const row = leaseDb.getTask(leaseConnection, id);
+      if (row && row.status !== 'claimed') leaseDb.clearLease(leaseConnection, { id, holder: taskActor });
+    }
+  }
 }

package/lib/gm-season.js

@@ -322,6 +322,12 @@ function outcomeFromEvent(row) {
   } else if (row.event_type === 'claim_released') {
     kind = 'dropped';
     member = payload.previous_claimed_by || payload.released_by || row.actor;
+  } else if (row.event_type === 'claim_expired') {
+    kind = 'dropped';
+    member = payload.claimed_by;
+  } else if ((row.event_type === 'proof_ready' || row.event_type === 'landing') && hasStructuredMerge(payload)) {
+    kind = 'landed';
+    member = holder;
   } else if (row.event_type === 'completed' && KEPT_ACTIONS.has(payload.action)) {
     kind = 'landed';
     member = holder;
@@ -340,6 +346,7 @@ function outcomeFromEvent(row) {
   const claimId = kind === 'took'
     ? (row.event_id || `${row.task_id}:${row.created_at}`)
     : (row.claim_event_id || `${row.task_id}:before`);
+  const leaseUntil = typeof payload.lease_until === 'number' ? payload.lease_until : typeof payload.lease_until === 'string' ? Date.parse(payload.lease_until) : NaN;
   return {
     event_id: row.event_id || null,
     claim_id: claimId,
@@ -347,14 +354,56 @@ function outcomeFromEvent(row) {
     member: String(member),
     title: row.title || '',
     kind,
-    at: Number(row.created_at),
+    at: row.event_type === 'claim_expired' && Number.isFinite(leaseUntil) ? leaseUntil : Number(row.created_at),
+    reason: kind !== 'took' && kind !== 'landed' ? (typeof payload.reason === 'string' && payload.reason.trim() || typeof payload.note === 'string' && payload.note.trim() || null) : null,
     claimed_at: claimedAt,
     landed_by: kind === 'landed' ? landedBy(row, payload) : null,
   };
 }
 
-function outcomesFromEvents(rows) {
-  return (rows || []).map(outcomeFromEvent).filter(Boolean).sort(byTimeAsc);
+function hasStructuredMerge(payload) {
+  const objects = [payload, payload.landing, payload.pull_request, payload.pr].filter(x => x && typeof x === 'object' && !Array.isArray(x));
+  return objects.some(x => {
+    const commit = x.merge_commit || x.merge_commit_sha || x.merge_sha;
+    return (typeof commit === 'string' && /^[0-9a-f]{7,64}$/i.test(commit)) ||
+      x.merged === true || Boolean(x.merged_at) ||
+      ((typeof x.merged_pr === 'string' && x.merged_pr.trim() !== '') || (typeof x.merged_pr === 'number' && x.merged_pr > 0) || (x.merged_pr && typeof x.merged_pr === 'object' && (x.merged_pr.merged === true || x.merged_pr.state === 'merged' || x.merged_pr.merged_at))) ||
+      ((x.state === 'merged' || x.status === 'merged') && (x.number != null || x.url != null));
+  });
+}
+
+function outcomesFromEvents(rows, since = -Infinity) {
+  const ordered = [...(rows || [])].sort((a, b) => String(a.task_id).localeCompare(String(b.task_id)) ||
+    (a.version != null && b.version != null ? Number(a.version) - Number(b.version) : Number(a.created_at) - Number(b.created_at)));
+  const plays = [];
+  const finished = new Map();
+  const closed = new Set();
+  for (let i = 0; i < ordered.length; i++) {
+    const row = ordered[i];
+    const play = outcomeFromEvent(row);
+    const key = `${row.task_id}:${row.claim_event_id || `${row.task_id}:before`}`;
+    const ended = ['claim_released', 'claim_expired', 'completed', 'reopened', 'archived'].includes(row.event_type);
+    if (!play) { if (ended) closed.add(key); continue; }
+    if (play.kind === 'took') { plays.push(play); continue; }
+    if (row.event_type === 'claim_released') {
+      let next = null;
+      for (let j = i + 1; j < ordered.length && ordered[j].task_id === row.task_id; j++) {
+        if (ordered[j].event_type === 'claimed') { next = ordered[j]; break; }
+      }
+      const nextMember = next && (next.actor || (parseJson(next.payload) || {}).claimed_by);
+      if (next && nextMember &&
+          Number(next.created_at) >= Number(row.created_at) && Number(next.created_at) - Number(row.created_at) <= 120000 &&
+          String(nextMember) !== play.member) { closed.add(key); continue; }
+    }
+    const prior = finished.get(key);
+    if (!prior && !closed.has(key)) { finished.set(key, play); plays.push(play); }
+    else if (prior && !closed.has(key) && play.kind === 'landed' && prior.kind !== 'landed') {
+      plays[plays.indexOf(prior)] = play;
+      finished.set(key, play);
+    }
+    if (ended) closed.add(key);
+  }
+  return plays.filter(play => play.at >= since).sort(byTimeAsc);
 }
 
 function emptySeason(workspaceRoot, now) {
@@ -467,7 +516,7 @@ function missionLastAt(mission) {
 // right holder. `extraWhere` narrows it (one workspace, or none for the league).
 function playEventsSql(extraWhere = '') {
   return `
-    SELECT e.event_id, e.task_id, e.workspace_root, e.event_type, e.actor, e.payload, e.created_at,
+    SELECT e.event_id, e.task_id, e.workspace_root, e.event_type, e.actor, e.payload, e.created_at, e.version,
            t.title, t.claimed_by, t.claimed_at,
            c.event_id AS claim_event_id, c.created_at AS claim_event_at, c.actor AS claim_actor,
            CASE WHEN e.event_type = 'archived' AND c.event_id IS NOT NULL AND NOT EXISTS (
@@ -485,8 +534,8 @@ function playEventsSql(extraWhere = '') {
         SELECT p.event_id FROM task_events p
          WHERE p.task_id = e.task_id AND p.event_type = 'claimed' AND p.version < e.version
          ORDER BY p.version DESC LIMIT 1)
-     WHERE e.created_at >= ?
-       AND e.event_type IN ('claimed', 'claim_released', 'completed', 'revision_requested', 'reopened', 'archived')
+     WHERE EXISTS (SELECT 1 FROM task_events recent WHERE recent.task_id = e.task_id AND recent.created_at >= ?)
+       AND e.event_type IN ('claimed', 'claim_released', 'claim_expired', 'proof_ready', 'landing', 'completed', 'revision_requested', 'reopened', 'archived')
        ${extraWhere}
      ORDER BY e.created_at ASC`;
 }
@@ -531,10 +580,10 @@ function loadSeason(workspaceRoot, { now = Date.now(), days = SEASON_DAYS, dbPat
     db = new DatabaseSync(target, { readOnly: true });
     const since = now - days * DAY_MS;
     const playsSince = db.prepare(playEventsSql('AND e.workspace_root = ?'));
-    season.outcomes = outcomesFromEvents(playsSince.all(since, workspaceRoot));
+    season.outcomes = outcomesFromEvents(playsSince.all(since, workspaceRoot), since);
     const seenAt = Number(season.last_seen_at);
     season.recap_outcomes = Number.isFinite(seenAt) && seenAt > 0 && seenAt < since
-      ? outcomesFromEvents(playsSince.all(seenAt, workspaceRoot))
+      ? outcomesFromEvents(playsSince.all(seenAt, workspaceRoot), seenAt)
       : null;
 
     const taskRows = db.prepare(`
@@ -588,7 +637,7 @@ function loadTargetView(db, workspaceRoot, { now, since, playsSince, outcomes, c
   const gmTarget = require('./gm-target');
   const store = gmTarget.readTargets(workspaceRoot, dir ? { dir } : {});
   const from = gmTarget.historyStart(store, now);
-  const history = db && from < since ? outcomesFromEvents(playsSince.all(from, workspaceRoot)) : outcomes;
+  const history = db && from < since ? outcomesFromEvents(playsSince.all(from, workspaceRoot), from) : outcomes;
   const hasPastWeeks = Object.keys(store.weeks).some(k => k < gmTarget.weekKey(now));
   return {
     has_target: Object.keys(store.weeks).length > 0,
@@ -758,7 +807,7 @@ function loadLeague({ now = Date.now(), days = SEASON_DAYS, dbPath, isClub = isC
     }
     const gmTarget = require('./gm-target');
     league.clubs = [...byRoot.values()].map((club) => {
-      const outcomes = outcomesFromEvents(club.events);
+      const outcomes = outcomesFromEvents(club.events, since);
       const store = gmTarget.readTargets(club.root, targetsDir ? { dir: targetsDir } : {});
       return {
         root: club.root,
@@ -1111,11 +1160,9 @@ function loadReplay({ workspaceRoot = null, since, now = Date.now(), dbPath, lea
     // same unique labels as the league, so /one/app and /two/app stay apart
     const names = clubNames([...new Set(kept.map(row => row.workspace_root))]);
     const clubOf = root => names.get(root) || path.basename(root);
-    out.plays = kept
-      .map(row => ({ row, play: outcomeFromEvent(row) }))
-      .filter(x => x.play && Number(x.play.at) <= now)
-      .map(x => ({ ...x.play, club: clubOf(x.row.workspace_root) }))
-      .sort(byTimeAsc);
+    const rootByTask = new Map(kept.map(row => [row.task_id, row.workspace_root]));
+    out.plays = outcomesFromEvents(kept, since).filter(play => play.at <= now)
+      .map(play => ({ ...play, club: clubOf(rootByTask.get(play.task_id)) }));
     const claimed = db.prepare(`
       SELECT id, workspace_root, claimed_by, claimed_at, updated_at,
              (SELECT MAX(e.created_at) FROM task_events e WHERE e.task_id = tasks.id) AS last_event_at

package/lib/task-db.js

@@ -580,7 +580,7 @@ function workspaceHead(workspaceRoot) {
 // Atomic claim. Returns { claimed: true, row } only if THIS call won the row.
 // Race-safe via single UPDATE with WHERE status='open' guard. SQLite serializes
 // writes; busy_timeout absorbs contention. Caller must check `.claimed`.
-function claimTask(db, { id, claimedBy }) {
+function claimTask(db, { id, claimedBy, leaseMinutes, leasePid }) {
   if (!id) throw new Error('id required');
   if (!claimedBy) throw new Error('claimedBy required');
   const now = Date.now();
@@ -589,11 +589,13 @@ function claimTask(db, { id, claimedBy }) {
        SET status = 'claimed',
            claimed_by = ?,
            claimed_at = ?,
-           updated_at = ?
+           updated_at = ?,
+           metadata = CASE WHEN ? IS NULL THEN metadata ELSE json_set(COALESCE(metadata, '{}'), '$.lease', json(?)) END
      WHERE id = ?
        AND status = 'open'
   `);
-  const result = withBusyRetry(() => stmt.run(claimedBy, now, now, id));
+  const lease = leaseMinutes == null ? null : JSON.stringify({ until: new Date(now + leaseMinutes * 60000).toISOString(), minutes: leaseMinutes, holder: claimedBy, pid: leasePid });
+  const result = withBusyRetry(() => stmt.run(claimedBy, now, now, lease, lease, id));
   if (result.changes === 1) {
     let row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
     // First claim wins: a re-claim after a revision keeps the original start.
@@ -621,6 +623,106 @@ function claimTask(db, { id, claimedBy }) {
   return { claimed: false, reason: 'already_' + row.status, claimed_by: row.claimed_by };
 }
 
+// Lease updates are guarded by the holder and do not create activity events.
+function setLease(db, { id, holder, minutes = 60, pid = process.pid, now = Date.now() }) {
+  const raw = db.prepare('SELECT metadata FROM tasks WHERE id = ?').get(id);
+  const row = getTask(db, id);
+  if (!row || row.metadata_unreadable || row.status !== 'claimed' || row.claimed_by !== holder) return false;
+  const metadata = { ...(row.metadata || {}), lease: { until: new Date(Number(now) + minutes * 60000).toISOString(), minutes, holder, pid } };
+  return withBusyRetry(() => db.prepare("UPDATE tasks SET metadata = ? WHERE id = ? AND status = 'claimed' AND claimed_by = ? AND metadata IS ?")
+    .run(JSON.stringify(metadata), id, holder, raw.metadata)).changes === 1;
+}
+
+function renewLease(db, options) {
+  const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(options.id);
+  const metadata = row && row.metadata ? safeJSON(row.metadata) : null;
+  const lease = metadata && metadata.lease;
+  if (!row || row.status !== 'claimed' || row.claimed_by !== options.holder || !lease || lease.holder !== options.holder || (options.pid != null && lease.pid !== options.pid)) return false;
+  const minutes = options.minutes ?? lease.minutes;
+  const now = options.now ?? Date.now();
+  const updated = { ...metadata, lease: { until: new Date(Number(now) + minutes * 60000).toISOString(), minutes, holder: options.holder, pid: options.pid ?? lease.pid } };
+  return withBusyRetry(() => db.prepare("UPDATE tasks SET metadata = ? WHERE id = ? AND status = 'claimed' AND claimed_by = ? AND claimed_at IS ? AND metadata IS ?")
+    .run(JSON.stringify(updated), row.id, row.claimed_by, row.claimed_at, row.metadata)).changes === 1;
+}
+
+function clearLease(db, { id, holder }) {
+  const raw = db.prepare('SELECT metadata FROM tasks WHERE id = ?').get(id);
+  const row = getTask(db, id);
+  if (!row || !row.metadata || !row.metadata.lease || row.metadata.lease.holder !== holder) return false;
+  const metadata = { ...row.metadata };
+  delete metadata.lease;
+  return withBusyRetry(() => db.prepare('UPDATE tasks SET metadata = ? WHERE id = ? AND metadata IS ?')
+    .run(JSON.stringify(metadata), id, raw.metadata)).changes === 1;
+}
+
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; } catch (err) { return err.code === 'EPERM'; }
+}
+
+function expireLeases(db, { now = Date.now(), staleDays, claimer, dryRun = false, isAlive = pidAlive } = {}) {
+  const timestamp = now instanceof Date ? now.getTime() : typeof now === 'string' ? Date.parse(now) : Number(now);
+  if (!Number.isFinite(timestamp)) throw new Error('invalid now');
+  if (staleDays != null && (!Number.isFinite(Number(staleDays)) || Number(staleDays) < 0)) throw new Error('invalid stale days');
+  const rows = db.prepare(`SELECT t.*, (SELECT MAX(created_at) FROM task_events e WHERE e.task_id = t.id) AS last_seen_at FROM tasks t WHERE t.status = 'claimed'`).all();
+  const expired = [];
+  for (const row of rows) {
+    if (claimer && row.claimed_by !== claimer) continue;
+    const metadata = row.metadata ? safeJSON(row.metadata) : null;
+    const lease = metadata && metadata.lease;
+    const until = lease && (typeof lease.until === 'number' ? lease.until : Date.parse(lease.until));
+    let reason;
+    let leaseUntil;
+    if (lease && Number.isFinite(until) && until < timestamp) {
+      if (timestamp - until <= 12 * 3600000 && isAlive(lease.pid)) continue;
+      reason = `worker stopped without reporting back within ${lease.minutes ?? 60} minutes`;
+      leaseUntil = lease.until;
+    } else if (!lease && staleDays != null && row.last_seen_at != null && row.last_seen_at < timestamp - Number(staleDays) * 86400000 && (claimer ? row.claimed_by === claimer : String(row.claimed_by || '').startsWith('fleet-'))) {
+      reason = `stranded with no activity for over ${staleDays} days`;
+      leaseUntil = new Date(row.last_seen_at + 3600000).toISOString();
+    } else continue;
+    const lastSeen = lease && Number.isFinite(until) && Number.isFinite(Number(lease.minutes))
+      ? until - Number(lease.minutes) * 60000 : row.last_seen_at;
+    const payload = { claimed_by: row.claimed_by, lease_until: leaseUntil, last_seen_at: lastSeen == null ? null : new Date(lastSeen).toISOString(), reason };
+    const item = { id: row.id, title: row.title, ...payload };
+    if (dryRun) { expired.push(item); continue; }
+    withBusyRetry(() => db.exec('BEGIN IMMEDIATE'));
+    try {
+      const nextMetadata = metadata && typeof metadata === 'object' ? { ...metadata } : {};
+      delete nextMetadata.lease;
+      const changed = db.prepare(`UPDATE tasks SET status = 'open', claimed_by = NULL, claimed_at = NULL, updated_at = ?, metadata = ? WHERE id = ? AND status = 'claimed' AND claimed_by = ? AND updated_at = ? AND metadata IS ? AND (SELECT MAX(created_at) FROM task_events WHERE task_id = tasks.id) IS ?`)
+        .run(Date.now(), JSON.stringify(nextMetadata), row.id, row.claimed_by, row.updated_at, row.metadata, row.last_seen_at);
+      if (changed.changes === 1) {
+        appendTaskEvent(db, { taskId: row.id, workspaceRoot: row.workspace_root, actor: row.claimed_by, eventType: 'claim_expired', payload });
+        expired.push(item);
+      }
+      db.exec('COMMIT');
+    } catch (err) { db.exec('ROLLBACK'); throw err; }
+  }
+  return expired;
+}
+
+function previewExpiredLeases(options = {}) {
+  const target = getDbPath();
+  if (!fs.existsSync(target)) return [];
+  const reader = new DatabaseSync(target, { readOnly: true });
+  try { return expireLeases(reader, { ...options, dryRun: true }); } finally { reader.close(); }
+}
+
+// Avoid creating or rewriting an idle database just to check for expired work.
+function sweepExpiredLeases() {
+  try {
+    const target = getDbPath();
+    if (!fs.existsSync(target)) return [];
+    const reader = new DatabaseSync(target, { readOnly: true });
+    let candidates;
+    try { candidates = expireLeases(reader, { dryRun: true }); } finally { reader.close(); }
+    return candidates.length ? expireLeases(open(target)) : [];
+  } catch (err) {
+    if (process.env.ATRIS_DEBUG) process.stderr.write(`lease sweep failed: ${String(err?.message ?? err).replace(/[\r\n]+/g, ' ')}\n`);
+    return [];
+  }
+}
+
 function releaseTask(db, { id, actor, expectedUpdatedAt }) {
   if (!id) throw new Error('id required');
   if (!actor) throw new Error('actor required');
@@ -638,7 +740,8 @@ function releaseTask(db, { id, actor, expectedUpdatedAt }) {
        SET status = 'open',
            claimed_by = NULL,
            claimed_at = NULL,
-           updated_at = ?
+           updated_at = ?,
+           metadata = CASE WHEN json_valid(metadata) THEN json_remove(metadata, '$.lease') ELSE metadata END
      WHERE id = ?
        AND status = 'claimed'
        AND claimed_by = ?
@@ -952,6 +1055,7 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
   }
   const now = Date.now();
   const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  delete metadata.lease;
   const reviewPassCount = Number(metadata.agent_review_pass_count || 0) + 1;
   metadata.approval_status = 'pending';
   metadata.agent_review_pass_count = reviewPassCount;
@@ -993,9 +1097,9 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
            updated_at = ?,
            metadata = ?
      WHERE id = ?
-       AND status IN ('open', 'claimed', 'review')
-  `).run(now, JSON.stringify(metadata), id));
-  if (result.changes !== 1) return { ready: false, reason: 'not_open_claimed_or_review' };
+       AND status = ? AND claimed_by IS ? AND claimed_at IS ?
+  `).run(now, JSON.stringify(metadata), id, row.status, row.claimed_by, row.claimed_at));
+  if (result.changes !== 1) return { ready: false, reason: 'claim changed hands' };
   const updated = getTask(db, id);
   const payload = {
     proof: text,
@@ -2364,6 +2468,12 @@ module.exports = {
   listTasks,
   listTasksCached,
   claimTask,
+  setLease,
+  renewLease,
+  clearLease,
+  expireLeases,
+  previewExpiredLeases,
+  sweepExpiredLeases,
   releaseTask,
   reopenTask,
   backlogTask,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.25",
+  "version": "3.74.26",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",