atris 3.74.24 → 3.74.26

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-bet.js

@@ -4573,8 +4573,8 @@ function createBetDesk(deps) {
 
   // The team page: every member on the team, one row each. role is a few
   // words from its MEMBER.md. ovr is the board's own rating (atris gm
-  // --board): 60 to 99 from the share of finished jobs that landed in the
-  // last 30 days, "new" with 1 or 2 finished, and two dots with none
+  // --board): the Atris Rating, 25 to 99, of the finished jobs that landed
+  // in the last 30 days, "new" with 1 or 2 finished, and two dots with none
   // finished in that window (a first claim alone is not a rating) or no
   // task list to read. engine is the tool and the exact model the roster
   // gives the member (atris engine roster), two dots when no model is

package/lib/gm-season.js

@@ -10,6 +10,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { atrisRating } = require('./atris-rating');
 
 const HOUR_MS = 60 * 60 * 1000;
 const DAY_MS = 24 * HOUR_MS;
@@ -49,17 +50,18 @@ function tally(outcomes) {
   return out;
 }
 
-// round(60 + 39 * landed / finished), rookie under 3 finished jobs. This is
+// The Atris Rating of landed over finished (lib/atris-rating.js): 25 to 99,
+// where 99 means 99 of every 100, rookie under 3 finished jobs. This is
 // stricter than the website rule (kept / graded) on purpose: drops and
 // abandoned jobs count.
 function ovr(outcomes) {
   const { landed, finished } = tally(outcomes);
   if (finished < ROOKIE_FINISHED) return null;
-  return Math.round(60 + 39 * landed / finished);
+  return atrisRating(landed, finished);
 }
 
 // Each member's rating over one window of plays, the board's own numbers:
-// ovr is 60 to 99, or null for a rookie under 3 finished. A member with no
+// ovr is 25 to 99, or null for a rookie under 3 finished. A member with no
 // plays in the window is not in the map.
 function memberRatings(outcomes = []) {
   const groups = new Map();
@@ -320,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;
@@ -338,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,
@@ -345,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) {
@@ -465,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 (
@@ -483,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`;
 }
@@ -529,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(`
@@ -586,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,
@@ -756,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,
@@ -1109,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/known-commands.js

@@ -3,7 +3,7 @@
 const knownCommands = ['init', 'guide', 'doctor', 'doc-health', 'install', 'workspace', 'log', 'logs', 'later', 'idea', 'done', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', '99', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'tree', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'sync-checkout', 'zen',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'campaign', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'scoreboard', 'scorecard', 'rating', 'sync-checkout', 'zen',
                        'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'spend', 'api-key', 'agent-client', 'topup', 'buy', 'transactions', 'hire', 'hires', 'mail', 'design', 'mcp', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'link', 'playbook', 'feed', 'brief', 'social', 'host', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join', 'rsi', 'pay', 'trust'];
 

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/lib/team-lineup.js

@@ -6,6 +6,7 @@
 
 const { modelLabel } = require('./roster-models');
 const { rosterToolLabel } = require('./engine-registry');
+const { bootRatingText } = require('./atris-rating');
 const { suggestionCount } = require('./roster-suggest');
 
 const BUILT_IN_JOBS = Object.freeze(['build', 'review', 'search']);
@@ -52,6 +53,8 @@ function readLineupSafe(root = process.cwd(), now = new Date()) {
 
 // One boot line: the tool and model that runs each built-in job right now,
 // custom jobs only when all of them still fit. '' when nothing resolves.
+// A build job's model shows its combine rating (atris rating), since the
+// combine grades building only.
 // When the run record suggests a new order for any job, a short marker
 // points at the roster view; only the end of the record is read.
 function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs = null } = {}) {
@@ -63,7 +66,9 @@ function bootTeamLine(root = process.cwd(), { width = 69, now = new Date(), jobs
   const ordered = orderJobs(rows);
   const part = (row) => {
     const text = shortRuns(row.now_runs);
-    return text ? `${row.job} ${text}` : '';
+    if (!text) return '';
+    const rated = row.role === 'executor' ? bootRatingText(row.now_runs.model) : '';
+    return `${row.job} ${text}${rated}`;
   };
   const builtIn = ordered.filter((row) => BUILT_IN_JOBS.includes(row.job) && !row.key).map(part).filter(Boolean);
   const custom = ordered.filter((row) => !BUILT_IN_JOBS.includes(row.job) || row.key).map(part).filter(Boolean);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.24",
+  "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",