atris 3.70.0 → 3.71.0

package/lib/member-map-inbox.js

@@ -0,0 +1,80 @@
+'use strict';
+
+// Member branches stop editing the shared map files. Before a branch goes to
+// GitHub, its edits to any MAP.md or MAP-NOTES.md that already exist on the
+// main branch are taken back out and saved as a patch in the map inbox, one
+// file per branch. The shared map files land untouched, so two members never
+// clash in them; the inbox patches are folded into the maps later on the main
+// branch by one actor.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const INBOX_DIR = 'atris/refs/map-inbox';
+const SHARED_MAP = /(?:^|\/)MAP(?:-NOTES)?\.md$/;
+
+function run(args, cwd, extraEnv = {}, { raw = false } = {}) {
+  const env = { ...process.env, ...extraEnv, GIT_NO_REPLACE_OBJECTS: '1' };
+  const res = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 120000, env });
+  const stdout = String(res.stdout || '');
+  return { ok: res.status === 0, stdout: raw ? stdout : stdout.trim(), stderr: String(res.stderr || '').trim() };
+}
+
+function inboxPath(branch) {
+  const slug = String(branch || '').replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|-+$/g, '') || 'branch';
+  return `${INBOX_DIR}/${slug}.patch`;
+}
+
+const SHA = /^[0-9a-f]{40,64}$/;
+
+// Returns { sha } unchanged when the branch left the shared maps alone, or
+// { sha, moved, inbox } for a new commit on top of headSha whose shared map
+// files match the starting point and whose map edits sit in the inbox patch.
+// Never touches the checkout. Any failure returns { hold }.
+function inboxMapEdits({ headSha, baseSha, branch, cwd }) {
+  const bases = run(['merge-base', '--all', headSha, baseSha], cwd);
+  const mergeBase = bases.ok ? bases.stdout.split('\n').filter(Boolean) : [];
+  if (mergeBase.length !== 1) return { sha: headSha, moved: [] };
+  const changed = run(['diff', '--no-renames', '--name-status', mergeBase[0], headSha], cwd);
+  if (!changed.ok) return { hold: 'the branch\'s map edits could not be read' };
+  const moved = changed.stdout.split('\n')
+    .map((line) => line.split('\t'))
+    .filter(([status, file]) => status === 'M' && SHARED_MAP.test(file || ''))
+    .map(([, file]) => file);
+  if (!moved.length) return { sha: headSha, moved: [] };
+
+  const patch = run(['diff', '--no-color', '--no-ext-diff', '--no-renames', mergeBase[0], headSha, '--', ...moved], cwd, {}, { raw: true });
+  if (!patch.ok || !patch.stdout) return { hold: 'the branch\'s map edits could not be saved' };
+  const inbox = inboxPath(branch);
+  const earlier = run(['cat-file', 'blob', `${headSha}:${inbox}`], cwd, {}, { raw: true });
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-map-inbox-'));
+  try {
+    const index = { GIT_INDEX_FILE: path.join(tmp, 'index') };
+    if (!run(['read-tree', headSha], cwd, index).ok) return { hold: 'the map inbox could not be built' };
+    for (const file of moved) {
+      const entry = run(['ls-tree', mergeBase[0], '--', file], cwd).stdout.match(/^(\d{6}) blob ([0-9a-f]{40,64})\t/);
+      if (!entry || !run(['update-index', '--cacheinfo', `${entry[1]},${entry[2]},${file}`], cwd, index).ok) {
+        return { hold: `the map file ${file} could not be put back` };
+      }
+    }
+    const patchFile = path.join(tmp, 'patch');
+    fs.writeFileSync(patchFile, (earlier.ok ? earlier.stdout : '') + patch.stdout);
+    const blob = run(['hash-object', '-w', patchFile], cwd);
+    if (!blob.ok || !SHA.test(blob.stdout)) return { hold: 'the map inbox could not be saved' };
+    if (!run(['update-index', '--add', '--cacheinfo', `100644,${blob.stdout},${inbox}`], cwd, index).ok) {
+      return { hold: 'the map inbox could not be built' };
+    }
+    const tree = run(['write-tree'], cwd, index);
+    if (!tree.ok) return { hold: 'the map inbox could not be built' };
+    const commit = run(['commit-tree', tree.stdout, '-p', headSha, '-m', 'Move map edits to the map inbox'], cwd);
+    if (!commit.ok || !SHA.test(commit.stdout)) return { hold: 'the map inbox commit could not be saved' };
+    return { sha: commit.stdout, moved, inbox };
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+module.exports = { inboxMapEdits, inboxPath, INBOX_DIR };

package/lib/member-progress.js

@@ -7,6 +7,51 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
+const MAX_PROGRESS_BYTES = 256 * 1024;
+const KEEP_PROGRESS_BYTES = 128 * 1024;
+
+// Progress is a live view, not the durable mission receipt. Keep whole recent
+// lines and the latest start marker so the board still knows the job and pid.
+// Scan backwards in bounded chunks even when upgrading a very large old log.
+function trimProgress(file) {
+  const fd = fs.openSync(file, 'r');
+  let recent;
+  let started = '';
+  try {
+    const size = fs.fstatSync(fd).size;
+    if (size <= MAX_PROGRESS_BYTES) return;
+    const from = Math.max(0, size - KEEP_PROGRESS_BYTES);
+    const tail = Buffer.alloc(size - from);
+    fs.readSync(fd, tail, 0, tail.length, from);
+    recent = tail.subarray(from ? tail.indexOf(0x0a) + 1 : 0).toString('utf8');
+    let end = size;
+    let partial = Buffer.alloc(0);
+    while (end > 0 && !started) {
+      const begin = Math.max(0, end - KEEP_PROGRESS_BYTES);
+      const chunk = Buffer.alloc(end - begin);
+      fs.readSync(fd, chunk, 0, chunk.length, begin);
+      const combined = Buffer.concat([chunk, partial]);
+      const boundary = begin ? combined.indexOf(0x0a) : -1;
+      partial = begin ? combined.subarray(0, boundary < 0 ? combined.length : boundary) : Buffer.alloc(0);
+      const lines = combined.subarray(begin ? boundary < 0 ? combined.length : boundary + 1 : 0).toString('utf8').split('\n');
+      for (let i = lines.length - 1; i >= 0; i--) {
+        if (/^\S+ \S+ started:/.test(lines[i])) { started = lines[i].slice(0, 500); break; }
+      }
+      // Malformed legacy lines must not make the backwards scan unbounded.
+      if (partial.length > KEEP_PROGRESS_BYTES) partial = Buffer.alloc(0);
+      end = begin;
+    }
+  } finally { fs.closeSync(fd); }
+  const prefix = started && !recent.includes(`${started}\n`) ? `${started}\n` : '';
+  const tmp = `${file}.${process.pid}.${newRunToken()}.tmp`;
+  try {
+    fs.writeFileSync(tmp, prefix + recent, 'utf8');
+    fs.renameSync(tmp, file);
+  } finally {
+    try { fs.unlinkSync(tmp); } catch {}
+  }
+}
+
 function realish(p) {
   try { return fs.realpathSync(p); } catch {}
   try { return path.join(fs.realpathSync(path.dirname(p)), path.basename(p)); } catch {}
@@ -144,7 +189,9 @@ function appendProgress(member, line, missionId) {
     const dir = progressDir();
     fs.mkdirSync(dir, { recursive: true });
     const entry = `${new Date().toISOString()} ${missionId || '-'} ${shortenLine(line)}\n`;
-    fs.appendFileSync(path.join(dir, `${safeMember(member)}.log`), entry, 'utf8');
+    const file = path.join(dir, `${safeMember(member)}.log`);
+    fs.appendFileSync(file, entry, 'utf8');
+    trimProgress(file);
   } catch {}
 }
 

package/lib/member-report.js

@@ -2,18 +2,24 @@
 
 // `atris member report [--since <time>] [--json]`: a short per-member summary
 // of what the team did. Four groups, newest first, one line per piece of work:
-//   merged       diary "Task completed" with action merged, plus the PR link
+//   merged       diary "Task completed" with action merged, plus the PR link, and
+//                pull requests GitHub merged from a member's branch (codex/<member>-...)
 //   finished     diary mission ticks whose check passed, accepted tasks, completed missions
 //   turned down  tasks a person sent back (task db) and tasks set aside (diary), with the reason
 //   waiting      tasks sitting in review for a person right now (task db)
 // Diary headings are `## HH:MM · title` in local time and the file name holds
 // the date, so every time here is local; nothing prints in UTC.
+// Merged and finished lines also say how long the job took (first pickup to
+// finish) and how many tries it needed (every run, failed or timed out too).
 
 const fs = require('fs');
 const path = require('path');
+const { spawnSync } = require('child_process');
 
 const DEFAULT_SINCE = '24h';
 const PER_GROUP = 3;
+// A job picked up before the window still gets its real start time.
+const HISTORY_DAYS = 7;
 const LOG_NAME_RE = /^(\d{4})-(\d{2})-(\d{2})\.md$/;
 const HEADING_RE = /^##\s+(\d{1,2}):(\d{2})\s*(?:·|-|:)?\s*(.*)$/;
 const FIELD_RE = /^-\s+([a-z_][a-z0-9_ ]*):\s*(.*)$/i;
@@ -174,6 +180,70 @@ function taskItems(tasks, sinceMs, members) {
   return items;
 }
 
+function jobKey(text) {
+  return String(text || '').trim().toLowerCase();
+}
+
+// Walks one member's diary oldest first and returns, for each entry that
+// finishes a job, { took_minutes, tries }. A job opens at its first pickup and
+// stays open through failed runs and re-pickups; a pickup after a passing run
+// opens a new job. Finishes with no pickup in the diary get nothing.
+function jobTimings(entries) {
+  const jobs = new Map();
+  const stamps = new Map();
+  for (const entry of [...entries].sort((a, b) => a.at - b.at)) {
+    const f = entry.fields;
+    const kind = entry.title.replace(/\s+\d+$/, '');
+    if (kind === 'Task claimed' || kind === 'Mission started') {
+      const key = jobKey(kind === 'Task claimed' ? f.title : f.mission);
+      const job = jobs.get(key);
+      if (key && (!job || job.done)) jobs.set(key, { startAt: entry.at.getTime(), tries: 0, done: false });
+      continue;
+    }
+    const finishKey = kind === 'Mission run tick' ? jobKey(f.mission)
+      : kind === 'Mission completed' ? jobKey(f.mission || f.title)
+        : kind === 'Task completed' || kind === 'Task accepted' ? jobKey(f.title) : null;
+    const job = finishKey && jobs.get(finishKey);
+    if (!job) continue;
+    if (kind === 'Mission run tick') {
+      if (job.done) continue;
+      job.tries += 1;
+      if (f.verifier !== 'passed') continue;
+      job.done = true;
+    }
+    const stamp = { took_minutes: Math.round((entry.at.getTime() - job.startAt) / 60e3) };
+    if (job.tries) stamp.tries = job.tries;
+    stamps.set(entry, stamp);
+  }
+  return stamps;
+}
+
+// Builder branches are `<engine>/<member>-<slug>`; the longest member name that
+// fits wins, so `codex-executor-x` is codex-executor, not a member named codex.
+function memberFromBranch(branch, members) {
+  const tail = String(branch || '').split('/').slice(1).join('/');
+  if (!tail) return null;
+  let best = null;
+  for (const name of members) {
+    if ((tail === name || tail.startsWith(`${name}-`)) && (!best || name.length > best.length)) best = name;
+  }
+  return best;
+}
+
+// Pull requests GitHub merged since the cutoff, credited to the member whose
+// branch they came from. A merge nobody wrote down still counts.
+function githubMergeItems(prs, sinceMs, members) {
+  const items = [];
+  for (const pr of prs || []) {
+    const at = Date.parse(pr && pr.mergedAt || '');
+    if (!Number.isFinite(at) || at < sinceMs) continue;
+    const member = memberFromBranch(pr.headRefName, members);
+    if (!member) continue;
+    items.push({ member, at, group: 'merged', title: pr.title, link: pr.url || null });
+  }
+  return items;
+}
+
 function sameTitle(a, b) {
   return String(a || '').trim().toLowerCase() === String(b || '').trim().toLowerCase();
 }
@@ -183,26 +253,35 @@ function summarize(items) {
   const sorted = [...items].sort((a, b) => b.at - a.at);
   for (const item of sorted) {
     if (!item.title) continue;
-    // Newest word on a piece of work wins, and merged beats finished.
-    if (Object.values(groups).some((list) => list.some((seen) => sameTitle(seen.title, item.title)))) continue;
+    // Newest word on a piece of work wins, and merged beats finished. A pull
+    // request a diary already logged shares its link, so it counts once.
+    const seenBefore = (seen) => sameTitle(seen.title, item.title) || (item.link && seen.link === item.link);
+    if (Object.values(groups).some((list) => list.some(seenBefore))) continue;
     const { member, at, group, ...rest } = item;
     groups[group].push(rest);
   }
   return groups;
 }
 
-function memberReport(root, { since = DEFAULT_SINCE, now = new Date(), tasks = [] } = {}) {
+function memberReport(root, { since = DEFAULT_SINCE, now = new Date(), tasks = [], merges = [] } = {}) {
   const sinceAt = parseSince(since, now);
   if (!sinceAt) throw new Error(`--since "${since}" is not a time; try 2h, yesterday, or 2026-10-14`);
   const names = memberNames(root);
   if (!names) throw new Error('no atris/team folder here; run this inside an atris workspace');
-  const fromTasks = taskItems(tasks, sinceAt.getTime(), names);
+  const fromTasks = taskItems(tasks, sinceAt.getTime(), names)
+    .concat(githubMergeItems(merges, sinceAt.getTime(), names));
+  const historyAt = new Date(sinceAt.getTime() - HISTORY_DAYS * 86400e3);
   const members = names
     .map((member) => {
-      const items = diaryEntriesSince(root, member, sinceAt)
+      const history = diaryEntriesSince(root, member, historyAt);
+      const timings = jobTimings(history);
+      const items = history
+        .filter((entry) => entry.at.getTime() >= sinceAt.getTime())
         .map((entry) => {
           const item = classifyDiaryEntry(entry);
-          return item ? { member, at: entry.at.getTime(), ...item } : null;
+          if (!item) return null;
+          const timing = item.group === 'merged' || item.group === 'finished' ? timings.get(entry) : null;
+          return { member, at: entry.at.getTime(), ...item, ...timing };
         })
         .filter(Boolean)
         .concat(fromTasks.filter((item) => item.member === member));
@@ -243,7 +322,26 @@ function firstSentence(text) {
   return match ? match[0] : flat;
 }
 
+// "took 3h 30m, 2 tries"; empty when the diary never showed the pickup.
+function timingText(item) {
+  if (!Number.isFinite(item.took_minutes)) return '';
+  const minutes = item.took_minutes;
+  const days = Math.floor(minutes / 1440);
+  const hours = Math.floor((minutes % 1440) / 60);
+  const mins = minutes % 60;
+  const took = minutes < 1 ? 'under a minute'
+    : days ? `${days}d${hours ? ` ${hours}h` : ''}`
+      : hours ? `${hours}h${mins ? ` ${mins}m` : ''}` : `${mins}m`;
+  const tries = item.tries ? `, ${item.tries} ${item.tries === 1 ? 'try' : 'tries'}` : '';
+  return `  took ${took}${tries}`;
+}
+
 function itemLine(key, item) {
+  if (key === 'merged' || key === 'finished') return baseLine(key, item) + timingText(item);
+  return baseLine(key, item);
+}
+
+function baseLine(key, item) {
   if (key === 'finished' && item.detail) return clip(firstSentence(item.detail), 90);
   if (key === 'merged') return item.link ? `${clip(item.title, 70)}  ${item.link}` : clip(item.title, 90);
   if (key === 'turned_down') return item.reason ? `${clip(item.title, 50)}: ${clip(item.reason, 70)}` : clip(item.title, 90);
@@ -280,6 +378,23 @@ function loadTasks(root) {
   }
 }
 
+// Merged pull requests from GitHub for this checkout. No gh, no remote, or no
+// login means an empty list: the report still prints what the diaries say.
+function loadGithubMerges(root, since) {
+  const day = new Date(since.getTime() - 86400e3).toISOString().slice(0, 10);
+  const result = spawnSync('gh', [
+    'pr', 'list', '--state', 'merged', '--search', `merged:>=${day}`, '--limit', '200',
+    '--json', 'title,headRefName,mergedAt,url',
+  ], { cwd: root, encoding: 'utf8', timeout: 20000 });
+  if (result.status !== 0) return [];
+  try {
+    const prs = JSON.parse(result.stdout);
+    return Array.isArray(prs) ? prs : [];
+  } catch {
+    return [];
+  }
+}
+
 function memberReportCommand(...args) {
   let parsed;
   try {
@@ -296,7 +411,9 @@ function memberReportCommand(...args) {
   let report;
   try {
     const root = process.cwd();
-    report = memberReport(root, { since: parsed.since, tasks: loadTasks(root) });
+    const sinceAt = parseSince(parsed.since);
+    const merges = sinceAt ? loadGithubMerges(root, sinceAt) : [];
+    report = memberReport(root, { since: parsed.since, tasks: loadTasks(root), merges });
   } catch (error) {
     console.error(error.message);
     process.exitCode = 1;
@@ -308,6 +425,8 @@ function memberReportCommand(...args) {
 
 module.exports = {
   formatReport,
+  githubMergeItems,
+  memberFromBranch,
   memberReport,
   memberReportCommand,
   parseSince,

package/lib/member-self-next-job.js

@@ -0,0 +1,97 @@
+'use strict';
+
+// When a member's job list is empty, it writes its own next job from its
+// standing mission (atris/team/<member>/MISSION.md) and keeps working. The
+// job is a normal open task: the North Star is the goal, and the mission's
+// `## Check` section names the command that proves a run. A mission with no
+// runnable check writes nothing, so the member stays idle as before. At most
+// one self-written job is open per member, and at most MAX_PER_DAY are
+// written per member per local day, so an idle team cannot spin forever.
+
+const fs = require('fs');
+const path = require('path');
+const { skipReason, taskCheck } = require('./member-task-pick');
+
+const MAX_PER_DAY = 12;
+const TITLE_MAX = 120;
+
+function oneLine(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+// The body of one `## <name>` section, up to the next `## ` heading.
+function section(text, name) {
+  const lines = String(text || '').split(/\r?\n/);
+  const start = lines.findIndex((line) => line.trim().toLowerCase() === `## ${name}`);
+  if (start < 0) return '';
+  const end = lines.findIndex((line, i) => i > start && /^##\s/.test(line));
+  return lines.slice(start + 1, end < 0 ? undefined : end).join('\n').trim();
+}
+
+// The job a mission file asks for next: its North Star as the goal and its
+// check command. null when either is missing.
+function missionNextJob(text) {
+  const northStar = oneLine(section(text, 'north star').split(/\n\s*\n/)[0]);
+  const checkBlock = section(text, 'check');
+  const tick = checkBlock.match(/`([^`\n]+)`/);
+  const check = oneLine(tick ? tick[1] : checkBlock.split(/\r?\n/).find((line) => line.trim()));
+  if (!northStar || !check) return null;
+  const goal = northStar.length > TITLE_MAX ? `${northStar.slice(0, TITLE_MAX - 3).trim()}...` : northStar;
+  return { title: `next step toward: ${goal}`, objective: northStar, check };
+}
+
+function localDay(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+// Write the member's next job from its mission. Returns { task } with the
+// new open task, or { skip } with a plain reason. dryRun returns the task it
+// would write without writing it.
+function writeSelfNextJob(taskDb, db, { root, workspaceRoot, member, job, now = Date.now(), dryRun = false }) {
+  let text;
+  try {
+    text = fs.readFileSync(path.join(root, 'atris', 'team', member, 'MISSION.md'), 'utf8');
+  } catch {
+    return { skip: 'no mission file' };
+  }
+  const next = missionNextJob(text);
+  if (!next) return { skip: 'mission names no north star or no check' };
+  const metadata = {
+    verify: next.check,
+    objective: next.objective,
+    written_by: member,
+    source: 'member mission',
+  };
+  const probe = { status: 'open', title: next.title, tag: job, metadata };
+  if (!taskCheck(probe).runnable) return { skip: 'mission check cannot be run here' };
+  const held = skipReason(probe, job, { requireCheck: true, member });
+  if (held) return { skip: `the job it would write is not one it can take (${held})` };
+
+  const prefix = `self-next:${member}:`;
+  const mine = db.prepare(
+    'SELECT id, status, source_key FROM tasks WHERE workspace_root = ? AND source_key LIKE ?'
+  ).all(workspaceRoot, `${prefix}%`);
+  if (mine.some((row) => row.status === 'open' || row.status === 'claimed')) {
+    return { skip: 'its last self-written job is still open' };
+  }
+  const day = localDay(now);
+  const today = mine.filter((row) => String(row.source_key).startsWith(`${prefix}${day}:`)).length;
+  if (today >= MAX_PER_DAY) return { skip: `already wrote ${MAX_PER_DAY} jobs for itself today` };
+
+  if (dryRun) return { task: { id: null, ...probe } };
+  const added = taskDb.addTask(db, {
+    title: next.title,
+    tag: job,
+    workspaceRoot,
+    sourceKey: `${prefix}${day}:${today + 1}`,
+    metadata,
+  });
+  return { task: taskDb.getTask(db, added.id) };
+}
+
+module.exports = {
+  MAX_PER_DAY,
+  missionNextJob,
+  writeSelfNextJob,
+};

package/lib/member-task-pick.js

@@ -1,8 +1,8 @@
 'use strict';
 
 // The next real job for a member with no idea given: the oldest open,
-// unclaimed task in this workspace whose job (build, review, search) matches
-// the member's, held neither for a human nor in a protected lane. Callers
+// unclaimed task assigned to them, then an unassigned task whose job (build,
+// review, search) matches theirs, held neither for a human nor in a protected lane. Callers
 // fall back to the member's own goal when this returns null, unless they
 // ask for requireCheck: then only tasks with a runnable check count, and
 // nothing found means the member stays idle.
@@ -66,32 +66,58 @@ function taskCheck(task) {
   return { command: verify, runnable: isAutoCertifyVerifyCommandAllowed(verify) };
 }
 
-function skipReason(task, job, { requireCheck = false } = {}) {
-  if (!task || task.status !== 'open') return 'not_open';
-  if (task.claimed_by) return 'claimed';
+function assigneeOf(task) {
+  const assigned = task?.metadata?.assigned_to;
+  return typeof assigned === 'string' ? assigned.trim() : '';
+}
+
+// Held for a person, the one test both the picker and the merge-line close
+// use, so a merge never closes a job the picker would leave alone.
+function heldForPerson(task) {
   if (isDecisionTask(task) || metadataTags(task).some(isDecisionHoldTag)) return 'needs_human';
   if (protectedTask(task)) return 'protected_lane';
+  return '';
+}
+
+function skipReason(task, job, { requireCheck = false, member, recoverClaimed = false } = {}) {
+  const ownClaim = recoverClaimed && member && task?.status === 'claimed' && task.claimed_by === member;
+  if (!task || (task.status !== 'open' && !ownClaim)) return 'not_open';
+  if (task.claimed_by && !ownClaim) return 'claimed';
+  const assignee = assigneeOf(task);
+  if (assignee && assignee !== member) return 'other_member';
+  const held = heldForPerson(task);
+  if (held) return held;
   const check = taskCheck(task);
   if (!check.runnable) return 'check_not_runnable';
   if (requireCheck && !check.command) return 'no_check';
-  if (jobForTask(task) !== job) return 'other_job';
+  // A named assignment is more specific than the inferred job type.
+  if (!assignee && jobForTask(task) !== job) return 'other_job';
   return '';
 }
 
-function fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck = false }) {
-  return taskDb.listTasks(db, { workspaceRoot, status: 'open' })
-    .filter((task) => !skipReason(task, job, { requireCheck }))
-    .sort((a, b) => (a.created_at - b.created_at) || String(a.id).localeCompare(String(b.id)));
+function fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck = false, member, recoverClaimed = false }) {
+  const tasks = taskDb.listTasks(db, { workspaceRoot, status: 'open' });
+  // Only a caller that checked the member has no live run may recover its
+  // own claim. Keep the same human, lane, job, and check gates.
+  if (recoverClaimed && member) tasks.push(...taskDb.listTasks(db, { workspaceRoot, status: 'claimed' }));
+  return tasks
+    .filter((task) => !skipReason(task, job, { requireCheck, member, recoverClaimed }))
+    .sort((a, b) => Number(Boolean(assigneeOf(b))) - Number(Boolean(assigneeOf(a)))
+      || (a.created_at - b.created_at) || String(a.id).localeCompare(String(b.id)));
 }
 
-function pickTaskForMember(taskDb, db, { workspaceRoot, job, requireCheck = false }) {
-  return fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck })[0] || null;
+function pickTaskForMember(taskDb, db, options) {
+  return fittingTasks(taskDb, db, options)[0] || null;
 }
 
 // Claim the oldest fitting task for the member. A lost race moves on to the
 // next candidate; null when nothing fits or every claim lost.
-function claimTaskForMember(taskDb, db, { workspaceRoot, member, job, requireCheck = false }) {
-  for (const task of fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck })) {
+function claimTaskForMember(taskDb, db, { workspaceRoot, member, job, requireCheck = false, recoverClaimed = false }) {
+  for (const task of fittingTasks(taskDb, db, { workspaceRoot, member, job, requireCheck, recoverClaimed })) {
+    if (task.status === 'claimed') {
+      const released = taskDb.releaseTask(db, { id: task.id, actor: member, expectedUpdatedAt: task.updated_at });
+      if (!released.released) continue;
+    }
     let result;
     try {
       result = taskDb.claimTask(db, { id: task.id, claimedBy: member });
@@ -109,6 +135,7 @@ module.exports = {
   taskCheck,
   claimTaskForMember,
   fittingTasks,
+  heldForPerson,
   jobForTask,
   pickTaskForMember,
   skipReason,