atris 3.68.9 → 3.70.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,59 @@ 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 : '') };
+}
+
+// How the member's most recent finished run ended: ok, failed, or stopped.
+// Looks past the current run, so a member busy again still shows how its
+// last job went. A stop wins over a "finished: failed" in the same run.
+function lastResult(text) {
+  const lines = text.split('\n').map(parseLine).filter(Boolean);
+  let end = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].text.startsWith('finished:')) { end = i; break; }
+  }
+  if (end < 0) return null;
+  let start = 0;
+  for (let i = end; i >= 0; i--) {
+    if (lines[i].text.startsWith('started:')) { start = i; break; }
+  }
+  const finishes = lines.slice(start, end + 1).filter((l) => l.text.startsWith('finished:'));
+  const stop = finishes.find((l) => /^finished:\s*stopped\b/.test(l.text));
+  const line = stop || lines[end];
+  const word = /^finished:\s*(\S*)/.exec(line.text)[1];
+  return { result: word || 'done', at: line.at };
+}
+
+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';
+  const result = lastResult(text);
   return {
     member: name,
     state,
-    job: startedLine ? cut(startedLine.text.slice('started:'.length), JOB_WIDTH) : '',
+    last_result: result ? result.result : '',
+    last_result_ago: result ? ago(now - result.at) : '',
+    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,
@@ -91,31 +153,74 @@ function memberRow(name, text, now) {
   };
 }
 
-function readBoard({ dir = progressDir(), now = Date.now(), all = false } = {}) {
+// A member put to sleep says so on the board, even with no progress log.
+// Sleep does not end a run already going, so that run reads as finishing.
+function markAsleep(row) {
+  const live = (row.state === 'working' || row.state === 'quiet') && row.alive !== false;
+  return { ...row, state: live ? 'asleep after this run' : 'asleep', asleep: true, idle: false };
+}
+
+function asleepRow(member) {
+  return {
+    member, state: 'asleep', last_result: '', last_result_ago: '', asleep: true, pid: null, engine: '', alive: null,
+    running_for: '', job: '', step: '', ago: '-', at: 0, idle: false,
+  };
+}
+
+// The progress folder is shared by every project on this computer. `only`
+// names the members to show; null shows every log.
+function readBoard({ dir = progressDir(), now = Date.now(), all = false, asleep = [], only = null } = {}) {
   let files = [];
   try { files = fs.readdirSync(dir).filter((f) => f.endsWith('.log')); } catch {}
+  if (only) files = files.filter((f) => only.includes(f.slice(0, -'.log'.length)));
+  const sleeping = new Set(asleep);
   const rows = [];
   for (const f of files) {
     let text = '';
     try { text = readTail(path.join(dir, f)); } catch { continue; }
     const row = memberRow(f.slice(0, -'.log'.length), text, now);
-    if (row) rows.push(row);
+    if (row) rows.push(sleeping.has(row.member) ? markAsleep(row) : { ...row, asleep: false });
+  }
+  for (const name of sleeping) {
+    if (!rows.some((r) => r.member === name)) rows.push(asleepRow(name));
   }
   return rows.filter((r) => all || !r.idle).sort((a, b) => b.at - a.at);
 }
 
+// Members of this project: one folder each under atris/team. Outside an
+// Atris project there is no team, so the board shows every log (null).
+function teamHere(root = process.cwd()) {
+  try {
+    return fs.readdirSync(path.join(root, 'atris', 'team'), { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !/^[._]/.test(e.name))
+      .map((e) => e.name);
+  } catch { return null; }
+}
+
+// Members the sleep switch has off in this workspace.
+function sleepingHere() {
+  try { return require('./member-switches').asleepMembers(process.cwd()); } catch { return []; }
+}
+
 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.last_result ? `${r.last_result} ${r.last_result_ago}` : '-',
+    r.alive === null ? '-' : (r.alive ? 'yes' : 'no'),
+    r.engine || '-',
+    r.running_for || '-',
+    r.ago,
+    r.job || '-',
+    r.step || '-',
+  ]);
+  const head = ['member', 'state', 'last result', '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 +246,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 +277,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 +305,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 +319,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,14 +336,126 @@ 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'],
+});
+// Engines whose member run may be led by the login shell that launched them.
+const SHELL_LAUNCHED = Object.freeze(['codex']);
+
+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] || '');
+  // The codex mission runner leads its group with a login shell whose script
+  // opens with the marker as a no-op: sh -lc ': atris-run <member> <run>; ...'.
+  const viaShell = SHELL_LAUNCHED.includes(key) && program === 'sh';
+  if (!programs.includes(program) && !viaShell) 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.
+  const shape = viaShell
+    ? `^\\S+\\s+-lc\\s+:\\s+${escaped};`
+    : `^\\S+\\s+-p\\s+${escaped}(?=\\s|\\\\012|\\?|$)`;
+  if (!new RegExp(shape).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');
+  const only = teamHere();
   if (args.includes('--follow')) {
     const dir = progressDir();
     const write = (obj) => process.stdout.write(`${JSON.stringify(obj)}\n`);
-    write({ kind: 'snapshot', at: new Date().toISOString(), dir, members: readBoard({ dir, all }) });
-    const follower = followBoard({ dir, emit: write });
+    write({ kind: 'snapshot', at: new Date().toISOString(), dir, members: readBoard({ dir, all, asleep: sleepingHere(), only }) });
+    const follower = followBoard({ dir, emit: (event) => { if (!only || only.includes(event.member)) write(event); } });
     // Runs until ctrl-c or the reader closes the pipe.
     return new Promise((resolve) => {
       const done = () => { follower.stop(); resolve(); };
@@ -239,11 +464,11 @@ function memberBoardCommand(...args) {
     });
   }
   if (asJson) {
-    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard({ all }) }, null, 2));
+    console.log(JSON.stringify({ ok: true, dir: progressDir(), members: readBoard({ all, asleep: sleepingHere(), only }) }, null, 2));
     return;
   }
   const draw = () => {
-    const every = readBoard({ all: true });
+    const every = readBoard({ all: true, asleep: sleepingHere(), only });
     const rows = all ? every : every.filter((r) => !r.idle);
     return renderBoard(rows, progressDir(), every.length - rows.length);
   };
@@ -260,4 +485,7 @@ function memberBoardCommand(...args) {
   });
 }
 
-module.exports = { readBoard, renderBoard, memberRow, ago, progressEvent, followBoard, memberBoardCommand };
+module.exports = {
+  readBoard, renderBoard, memberRow, ago, progressEvent, followBoard, memberBoardCommand,
+  parseStarted, teamHere, 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 };