atris 3.68.9 → 3.69.0

package/lib/member-board.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { RUN_TAG, runMarker } = require('./member-progress');
 
 const QUIET_AFTER_MS = 2 * 60 * 1000;
 const HIDE_DONE_AFTER_MS = 60 * 60 * 1000;
@@ -38,7 +39,23 @@ function parseLine(raw) {
   if (!m) return null;
   const at = Date.parse(m[1]);
   if (Number.isNaN(at)) return null;
-  return { at, text: m[3] };
+  return { at, mission: m[2], text: m[3] };
+}
+
+// "started: [pid 4242 engine claude] job" -> { pid, engine, job }. Older
+// lines have no tag, so pid stays null and the board cannot say if it lives.
+function parseStarted(text) {
+  const body = String(text || '').replace(/^started:\s*/, '');
+  const m = RUN_TAG.exec(body);
+  if (!m) return { pid: null, engine: '', run: '', job: body };
+  return { pid: Number(m[1]), engine: m[2] || '', run: m[3] || '', job: body.slice(m[0].length) };
+}
+
+// Signal 0 checks a process exists without touching it. EPERM means it
+// exists but belongs to someone else, which still counts as alive.
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
 }
 
 function cut(text, width) {
@@ -46,12 +63,16 @@ function cut(text, width) {
   return s.length > width ? `${s.slice(0, width - 3)}...` : s;
 }
 
-function ago(ms) {
+function span(ms) {
   const s = Math.max(0, Math.floor(ms / 1000));
-  if (s < 60) return `${s}s ago`;
-  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
-  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
-  return `${Math.floor(s / 86400)}d ago`;
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.floor(s / 60)}m`;
+  if (s < 86400) return `${Math.floor(s / 3600)}h`;
+  return `${Math.floor(s / 86400)}d`;
+}
+
+function ago(ms) {
+  return `${span(ms)} ago`;
 }
 
 function escapeRe(s) {
@@ -61,7 +82,7 @@ function escapeRe(s) {
 // The current run is everything from the latest "started:" line on.
 // Steps that only write the member's own log are housekeeping, so the last
 // step column skips them unless nothing else happened.
-function memberRow(name, text, now) {
+function currentRun(text) {
   const lines = text.split('\n').map(parseLine).filter(Boolean);
   if (!lines.length) return null;
   let start = 0;
@@ -71,18 +92,35 @@ function memberRow(name, text, now) {
   const run = lines.slice(start);
   const startedLine = run[0].text.startsWith('started:') ? run[0] : null;
   const finished = [...run].reverse().find((l) => l.text.startsWith('finished:'));
+  // A stop wins over the runner's own "finished: failed" that may land first.
+  const stopped = run.some((l) => /^finished:\s*stopped\b/.test(l.text));
+  return { run, startedLine, finished, stopped, meta: parseStarted(startedLine ? startedLine.text : '') };
+}
+
+function memberRow(name, text, now) {
+  const current = currentRun(text);
+  if (!current) return null;
+  const { run, startedLine, finished, stopped, meta } = current;
   const ownLog = new RegExp(`atris/team/${escapeRe(name)}/logs\\b`);
   const steps = run.filter((l) => !l.text.startsWith('started:') && !l.text.startsWith('finished:'));
   const real = steps.filter((l) => !ownLog.test(l.text));
   const step = real[real.length - 1] || steps[steps.length - 1];
   const last = run[run.length - 1];
+  const alive = finished || meta.pid === null ? null : isAlive(meta.pid);
   let state;
-  if (finished) state = /^finished:\s*ok\b/.test(finished.text) ? 'done ok' : 'done failed';
+  if (stopped) state = 'stopped';
+  else if (finished) state = /^finished:\s*ok\b/.test(finished.text) ? 'done ok' : 'done failed';
+  else if (alive === false) state = 'stopped';
   else state = now - last.at < QUIET_AFTER_MS ? 'working' : 'quiet';
   return {
     member: name,
     state,
-    job: startedLine ? cut(startedLine.text.slice('started:'.length), JOB_WIDTH) : '',
+    pid: meta.pid,
+    engine: meta.engine,
+    // null when the started line has no pid; false once the run is over.
+    alive: meta.pid === null ? null : alive === true,
+    running_for: alive ? span(now - startedLine.at) : '',
+    job: startedLine ? cut(meta.job, JOB_WIDTH) : '',
     step: step ? cut(step.text, STEP_WIDTH) : '',
     ago: ago(now - last.at),
     at: last.at,
@@ -107,15 +145,21 @@ function readBoard({ dir = progressDir(), now = Date.now(), all = false } = {})
 function renderBoard(rows, dir = progressDir(), hidden = 0) {
   const note = hidden ? `${hidden} finished over an hour ago, hidden. --all shows them` : '';
   if (!rows.length) return note ? `nobody is working right now. ${note}` : `no member progress yet in ${dir}`;
-  const w = (key, min) => Math.max(min, ...rows.map((r) => r[key].length));
-  const nameW = w('member', 6);
-  const stateW = w('state', 5);
-  const agoW = w('ago', 3);
-  const jobW = Math.max(3, ...rows.map((r) => (r.job || '-').length));
-  const pad = (s, n) => s.padEnd(n);
-  const line = (a, b, c, d, e) => `${pad(a, nameW)}  ${pad(b, stateW)}  ${pad(c, agoW)}  ${pad(d, jobW)}  ${e}`.trimEnd();
-  const out = [line('member', 'state', 'ago', 'job', 'last step')];
-  for (const r of rows) out.push(line(r.member, r.state, r.ago, r.job || '-', r.step || '-'));
+  const cells = rows.map((r) => [
+    r.member,
+    r.state,
+    r.alive === null ? '-' : (r.alive ? 'yes' : 'no'),
+    r.engine || '-',
+    r.running_for || '-',
+    r.ago,
+    r.job || '-',
+    r.step || '-',
+  ]);
+  const head = ['member', 'state', 'alive', 'engine', 'running for', 'ago', 'job', 'last step'];
+  const widths = head.map((h, i) => Math.max(h.length, ...cells.map((c) => c[i].length)));
+  const line = (c) => c.map((v, i) => (i === c.length - 1 ? v : v.padEnd(widths[i]))).join('  ').trimEnd();
+  const out = [line(head)];
+  for (const c of cells) out.push(line(c));
   if (note) out.push('', note);
   return out.join('\n');
 }
@@ -141,6 +185,11 @@ function progressEvent(member, raw) {
   if (tagged) {
     event.kind = tagged[1];
     event.text = tagged[2];
+    if (tagged[1] === 'started') {
+      const meta = parseStarted(tagged[2]);
+      event.text = meta.job;
+      if (meta.pid !== null) { event.pid = meta.pid; event.engine = meta.engine; }
+    }
     if (tagged[1] === 'finished') event.ok = /^ok\b/.test(tagged[2]);
   }
   return event;
@@ -167,13 +216,13 @@ function afterLastNewline(file) {
   } catch { return 0; } finally { fs.closeSync(fd); }
 }
 
-function followBoard({ dir = progressDir(), emit, pollMs = 1000 } = {}) {
+function followBoard({ dir = progressDir(), emit, pollMs = 1000, orderByTime = false } = {}) {
   const offsets = new Map();
   const sizeOf = (file) => { try { return fs.statSync(file).size; } catch { return null; } };
   const list = () => { try { return fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch { return []; } };
   for (const f of list()) offsets.set(f, afterLastNewline(path.join(dir, f)));
 
-  function readNew(f) {
+  function readNew(f, events) {
     const file = path.join(dir, f);
     const size = sizeOf(file);
     if (size === null) return;
@@ -195,7 +244,7 @@ function followBoard({ dir = progressDir(), emit, pollMs = 1000 } = {}) {
     const member = f.slice(0, -'.log'.length);
     for (const raw of buf.subarray(0, end).toString('utf8').split('\n')) {
       const event = progressEvent(member, raw.replace(/\r$/, ''));
-      if (event) emit(event);
+      if (event) events.push(event);
     }
   }
 
@@ -209,7 +258,10 @@ function followBoard({ dir = progressDir(), emit, pollMs = 1000 } = {}) {
         watcher.on('error', () => { try { watcher.close(); } catch {} watcher = null; });
       } catch { watcher = null; }
     }
-    for (const f of list()) readNew(f);
+    const events = [];
+    for (const f of list()) readNew(f, events);
+    if (orderByTime) events.sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+    for (const event of events) emit(event);
   }
   const timer = setInterval(scan, pollMs);
   scan();
@@ -223,6 +275,109 @@ function followBoard({ dir = progressDir(), emit, pollMs = 1000 } = {}) {
   };
 }
 
+// Stop a member's live run: SIGTERM its process group (the engine is spawned
+// detached, so the group is the run and everything it started), wait up to
+// graceMs, then SIGKILL whatever is left. Writes "finished: stopped" so the
+// board stops counting it. Resolves { ok, message } with one plain line.
+function signalRun(pid, sig) {
+  try { process.kill(-pid, sig); return; } catch {}
+  try { process.kill(pid, sig); } catch {}
+}
+
+function runAlive(pid) {
+  try { process.kill(-pid, 0); return true; } catch (e) { if (e.code === 'EPERM') return true; }
+  return isAlive(pid);
+}
+
+// Engines a member run can be, and the program name each one runs as.
+const ENGINE_PROGRAMS = Object.freeze({
+  claude: ['claude'], fable: ['claude'], haiku: ['claude'], codex: ['codex'],
+  cursor: ['cursor-agent'], composer: ['cursor-agent'], grok: ['grok'],
+  devin: ['devin'], agy: ['agy'], opencode: ['opencode'],
+});
+
+function readProcess(pid) {
+  const run = (fmt) => require('child_process').spawnSync('ps', ['-o', fmt, '-p', String(pid)], {
+    encoding: 'utf8', timeout: 3000, env: { ...process.env, LC_ALL: 'C', TZ: 'UTC' },
+  });
+  const head = run('pgid=,command=');
+  const born = run('lstart=');
+  if (head.status !== 0 || born.status !== 0) return null;
+  const m = /^\s*(\d+)\s+(.*)$/s.exec(String(head.stdout || '').trim());
+  const startedAt = Date.parse(`${String(born.stdout || '').trim()} UTC`);
+  return m ? { pgid: Number(m[1]), command: m[2], startedAt: Number.isFinite(startedAt) ? startedAt : null } : null;
+}
+
+// Only signal a pid that is, right now, a known engine program leading its
+// own process group, and never this process's own group or a system pid.
+// The engine process must have started within this many ms of the member's
+// own started line, which binds a stop to that exact run.
+const START_WINDOW_MS = 30000;
+
+function pidRunsEngine(pid, engine, deps = {}, startedLineAt = null, member = '', run = '') {
+  if (!Number.isInteger(pid) || pid <= 1 || pid === process.pid) return false;
+  const key = String(engine || '').trim().toLowerCase();
+  if (!Object.prototype.hasOwnProperty.call(ENGINE_PROGRAMS, key)) return false;
+  const programs = ENGINE_PROGRAMS[key];
+  const info = (deps.readProcess || readProcess)(pid);
+  if (!info || info.pgid !== pid) return false;
+  if (!Number.isFinite(startedLineAt) || !Number.isFinite(info.startedAt)
+    || Math.abs(info.startedAt - startedLineAt) > START_WINDOW_MS) return false;
+  const ownGroup = (deps.readProcess || readProcess)(process.pid);
+  if (ownGroup && ownGroup.pgid === pid) return false;
+  const program = path.basename(String(info.command).trim().split(/\s+/)[0] || '');
+  if (!programs.includes(program)) return false;
+  // The run token proves the process is this member's run: it is on the first
+  // line of the engine's prompt and in no other member's log.
+  if (!/^[0-9a-f]{16}$/.test(String(run || '')) || !member) return false;
+  // The marker must open the engine's prompt: right after its -p flag, as
+  // whole words, so a command that merely mentions it does not count.
+  const escaped = runMarker(member, run).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // The program, then -p, then the marker: nothing earlier can carry it. ps on
+  // macOS prints the prompt's line break as the four characters \\012.
+  if (!new RegExp(`^\\S+\\s+-p\\s+${escaped}(?=\\s|\\\\012|\\?|$)`).test(String(info.command))) return false;
+  return { startedAt: info.startedAt, command: info.command };
+}
+
+async function stopMember(name, { dir = progressDir(), graceMs = 10000, pollMs = 100, now = () => Date.now(), deps = {} } = {}) {
+  const nothing = { ok: false, message: 'nothing running' };
+  const member = String(name || '').trim();
+  if (!member || !/^[A-Za-z0-9._-]+$/.test(member)) return nothing;
+  const file = path.join(dir, `${member}.log`);
+  let text = '';
+  try { text = readTail(file); } catch { return nothing; }
+  const current = currentRun(text);
+  if (!current || current.finished || !current.startedLine) return nothing;
+  const { pid, engine, run } = current.meta;
+  if (pid === null || !runAlive(pid)) return nothing;
+  // A pid from a run that died without a finished line can be reused by an
+  // unrelated program; only signal it while its command is still the engine.
+  const identity = pidRunsEngine(pid, engine, deps, current.startedLine.at, member, run);
+  if (!identity) return nothing;
+
+  const startedAt = current.startedLine.at;
+  signalRun(pid, 'SIGTERM');
+  const deadline = now() + graceMs;
+  // Poll on timers, not a busy loop, so a test parent can reap its child.
+  while (runAlive(pid) && now() < deadline) await new Promise((r) => setTimeout(r, pollMs));
+  // Check identity again before the hard kill: the pid may have been reused.
+  // Before the hard kill, the process must be the very same one: same start
+  // time and same command, token included.
+  const again = runAlive(pid) && pidRunsEngine(pid, engine, deps, current.startedLine.at, member, run);
+  const forced = Boolean(again) && again.startedAt === identity.startedAt && again.command === identity.command;
+  if (forced) signalRun(pid, 'SIGKILL');
+
+  const mission = current.startedLine.mission || '-';
+  try { fs.appendFileSync(file, `${new Date().toISOString()} ${mission} finished: stopped\n`, 'utf8'); } catch {}
+  const how = forced ? ', it had to be forced' : '';
+  return { ok: true, pid, forced, message: `stopped ${member} after ${span(now() - startedAt)} of work${how}` };
+}
+
+async function memberStopCommand(name) {
+  const result = await stopMember(name);
+  console.log(result.message);
+}
+
 function memberBoardCommand(...args) {
   const asJson = args.includes('--json');
   const all = args.includes('--all');
@@ -260,4 +415,7 @@ function memberBoardCommand(...args) {
   });
 }
 
-module.exports = { readBoard, renderBoard, memberRow, ago, progressEvent, followBoard, memberBoardCommand };
+module.exports = {
+  readBoard, renderBoard, memberRow, ago, progressEvent, followBoard, memberBoardCommand,
+  parseStarted, isAlive, stopMember, memberStopCommand,
+};

package/lib/member-progress.js

@@ -50,6 +50,45 @@ function formatToolStep(block, cwd) {
   }
 }
 
+// Codex wraps each command in a login shell ("/bin/zsh -lc 'grep -n x a.txt'");
+// the line shows only what ran inside it.
+function unwrapShellCommand(command) {
+  const text = String(command || '').trim();
+  const match = text.match(/^(?:\S*\/)?(?:ba|z)?sh\s+-l?c\s+(['"])([\s\S]*)\1$/);
+  return match ? match[2] : text;
+}
+
+function searchPattern(command) {
+  const words = command.split(/\s+/).slice(1);
+  const word = words.find((w) => w && !w.startsWith('-')) || '';
+  return word.replace(/^(['"])(.*)\1$/, '$2');
+}
+
+// One plain line for a codex `exec --json` event, or null when the event is
+// not a step (messages, reasoning, turn bookkeeping). Commands show when they
+// start; file edits only arrive once done.
+function formatCodexEvent(event, cwd) {
+  if (!event || (event.type !== 'item.started' && event.type !== 'item.completed')) return null;
+  const item = event.item || {};
+  switch (item.type) {
+    case 'command_execution': {
+      const first = unwrapShellCommand(item.command).split('\n')[0].trim();
+      if (/^(rg|grep)\s/.test(first)) return `searching for ${searchPattern(first)}`;
+      return `running: ${first.slice(0, 70)}`;
+    }
+    case 'file_change': {
+      const files = (Array.isArray(item.changes) ? item.changes : [])
+        .map((change) => relativeTo(cwd, change && change.path))
+        .filter(Boolean);
+      return files.length ? `editing ${files.join(', ')}` : null;
+    }
+    case 'web_search':
+      return `searching for ${item.query || ''}`;
+    default:
+      return null;
+  }
+}
+
 function progressDir() {
   return process.env.ATRIS_PROGRESS_DIR || path.join(os.homedir(), '.atris', 'progress');
 }
@@ -62,13 +101,38 @@ function hhmm(date = new Date()) {
   return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
 }
 
+// A started line can name the run's process and engine up front:
+// "started: [pid 4242 engine claude] <objective>". The board reads the pid to
+// tell a live run from a dead one, and `atris member stop` kills its group.
+const RUN_TAG = /^\[pid (\d+)(?: engine (\S+))?(?: run ([0-9a-f]{16}))?\]\s*/;
+
+function startedLine(objective, { pid, engine, run } = {}) {
+  const runPart = /^[0-9a-f]{16}$/.test(String(run || '')) ? ` run ${run}` : '';
+  const tag = Number.isInteger(pid) && pid > 0 ? `[pid ${pid}${engine ? ` engine ${engine}` : ''}${runPart}] ` : '';
+  return `started: ${tag}${objective || ''}`;
+}
+
+// A one-time token for one engine run. It goes on the first line of the
+// engine's prompt (visible in its command line) and in the started line, so
+// member stop can prove a live process is that member's run.
+function newRunToken() {
+  return require('crypto').randomBytes(8).toString('hex');
+}
+
+function runMarker(member, token) {
+  return `atris-run ${member} ${token}`;
+}
+
 // One progress line stays one short line: a 'started:' objective keeps its
-// first line and at most 80 chars; any other line caps at 100.
+// first line and at most 80 chars (the run tag does not count); any other
+// line caps at 100.
 function shortenLine(line) {
   const first = String(line || '').split('\n')[0];
   if (first.startsWith('started: ')) {
-    const objective = first.slice('started: '.length);
-    return `started: ${objective.length > 80 ? `${objective.slice(0, 80)}...` : objective}`;
+    const body = first.slice('started: '.length);
+    const tag = (RUN_TAG.exec(body) || [''])[0];
+    const objective = body.slice(tag.length);
+    return `started: ${tag}${objective.length > 80 ? `${objective.slice(0, 80)}...` : objective}`;
   }
   return first.length > 100 ? `${first.slice(0, 100)}...` : first;
 }
@@ -91,4 +155,4 @@ function reportProgress(member, line, missionId) {
   appendProgress(member, short, missionId);
 }
 
-module.exports = { formatToolStep, appendProgress, reportProgress, shortenLine };
+module.exports = { formatToolStep, formatCodexEvent, appendProgress, reportProgress, shortenLine, startedLine, RUN_TAG, newRunToken, runMarker };

package/lib/member-task-pick.js

@@ -0,0 +1,116 @@
+'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
+// 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.
+
+const { autoJobForMember } = require('./member-engine');
+const { deniedTagOf, declaredProtectedLane, sniffedProtectedLane, isAutoCertifyVerifyCommandAllowed } = require('./auto-accept-certified');
+const { isDecisionHoldTag, isDecisionTask, taskTagTokens } = require('./task-decision');
+
+// A task's job uses the member rule with its tags in the name slot and its
+// title in the role slot: tags decide first, then the title, else build.
+function jobForTask(task) {
+  return autoJobForMember(taskTagTokens(task).join(' '), task && task.title);
+}
+
+function taskBody(task) {
+  const meta = (task && task.metadata) || {};
+  return ['objective', 'body', 'description', 'details']
+    .map((key) => (typeof meta[key] === 'string' ? meta[key].trim() : ''))
+    .find(Boolean) || '';
+}
+
+// The objective a member run gets: the title, then the body when there is one,
+// on one line. Mission start refuses objectives with line breaks.
+function taskObjective(task) {
+  const oneLine = (text) => String(text || '').replace(/\s+/g, ' ').trim();
+  const title = oneLine(task && task.title);
+  const body = oneLine(taskBody(task));
+  if (!body) return title;
+  return /[.!?]$/.test(title) ? `${title} ${body}` : `${title}. ${body}`;
+}
+
+// Held for a person: a denied tag on the row or in its metadata, a protected
+// lane declared anywhere in its text, or lane terms in its title or body.
+// Tags written in metadata, which the shared tag parser does not read.
+function metadataTags(task) {
+  const meta = (task && task.metadata) || {};
+  return [meta.tag, ...(Array.isArray(meta.tags) ? meta.tags : [])]
+    .filter((t) => typeof t === 'string' && t.trim())
+    .map((t) => t.trim().toLowerCase().replace(/^#/, ''));
+}
+
+function protectedTask(task) {
+  const meta = (task && task.metadata) || {};
+  const tags = [...metadataTags(task), ...taskTagTokens(task)];
+  if (deniedTagOf(task) || tags.some((tag) => deniedTagOf({ tag }))) return true;
+  // Every text field, not just the one the objective uses.
+  const allText = ['objective', 'body', 'description', 'details']
+    .map((key) => (typeof meta[key] === 'string' ? meta[key] : ''))
+    .filter(Boolean)
+    .join('\n');
+  const probe = { title: task.title, objective: allText, metadata: meta };
+  return Boolean(declaredProtectedLane(probe) || sniffedProtectedLane(probe));
+}
+
+// The check a task requires, when it names one. A check written as prose
+// that cannot be run means the task cannot be proven here.
+function taskCheck(task) {
+  const verify = task && task.metadata && typeof task.metadata.verify === 'string'
+    ? task.metadata.verify.trim() : '';
+  if (!verify) return { command: '', runnable: true };
+  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';
+  if (isDecisionTask(task) || metadataTags(task).some(isDecisionHoldTag)) return 'needs_human';
+  if (protectedTask(task)) return 'protected_lane';
+  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';
+  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 pickTaskForMember(taskDb, db, { workspaceRoot, job, requireCheck = false }) {
+  return fittingTasks(taskDb, db, { workspaceRoot, job, requireCheck })[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 })) {
+    let result;
+    try {
+      result = taskDb.claimTask(db, { id: task.id, claimedBy: member });
+    } catch (error) {
+      // A claim that half-wrote must not strand the task.
+      try { taskDb.releaseTask(db, { id: task.id, actor: member }); } catch {}
+      throw error;
+    }
+    if (result.claimed) return { task: result.row, objective: taskObjective(result.row) };
+  }
+  return null;
+}
+
+module.exports = {
+  taskCheck,
+  claimTaskForMember,
+  fittingTasks,
+  jobForTask,
+  pickTaskForMember,
+  skipReason,
+  taskObjective,
+};