atris 3.68.9 → 3.69.0

package/lib/member-tidy.js

@@ -0,0 +1,235 @@
+'use strict';
+
+// `atris member tidy`: put away member copies of the repo (git worktrees under
+// <arena>/.agent-worktrees/<repo>) whose work already landed. There is no
+// deletion logic here on purpose. git does the removing with
+// `git worktree remove` (never --force), which refuses modified or untracked
+// files, then `git branch -d` (never -D). Everything this file decides is
+// about which copies to leave alone:
+//   - work not landed: branch tip is not an ancestor of origin's default
+//     branch tip, asked of origin itself on every run. Listed with its age, never touched.
+//   - any git error while deciding: skipped.
+//   - a live process inside the copy (lsof). If the scan itself fails, every
+//     copy is skipped.
+//   - a copy whose real path is outside the real worktrees folder (a symlink).
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function git(args, cwd) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', timeout: 60000 });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: String(result.stdout || '').trim(),
+    stderr: String(result.stderr || result.error?.message || '').trim(),
+  };
+}
+
+function isUnder(child, parent) {
+  const rel = path.relative(parent, child);
+  return Boolean(rel) && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function firstLine(text) {
+  return String(text || '').split('\n').map((line) => line.trim()).find(Boolean) || 'no reason given';
+}
+
+function formatAge(ms) {
+  const minutes = Math.max(0, Math.floor(ms / 60000));
+  if (minutes < 60) return `${minutes}m old`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h old`;
+  return `${Math.floor(hours / 24)}d old`;
+}
+
+function mainRepoRoot(cwd) {
+  const common = git(['rev-parse', '--path-format=absolute', '--git-common-dir'], cwd);
+  if (!common.ok) return null;
+  return path.basename(common.stdout) === '.git' ? path.dirname(common.stdout) : common.stdout;
+}
+
+function defaultWorktreesDir(repoRoot) {
+  return path.join(path.dirname(repoRoot), '.agent-worktrees', path.basename(repoRoot));
+}
+
+function parseWorktreeList(text) {
+  const entries = [];
+  let current = null;
+  for (const line of String(text || '').split('\n')) {
+    if (line.startsWith('worktree ')) {
+      current = { path: line.slice('worktree '.length), branch: null };
+      entries.push(current);
+    } else if (current && line.startsWith('branch refs/heads/')) {
+      current.branch = line.slice('branch refs/heads/'.length);
+    }
+  }
+  return entries;
+}
+
+// Ask origin itself which branch it ships from and where that branch is right
+// now. The local origin/HEAD note goes stale when the default branch changes,
+// so it is never trusted. Returns the exact commit to compare against.
+function originDefaultTip(repoRoot) {
+  const remote = git(['ls-remote', '--symref', 'origin', 'HEAD'], repoRoot);
+  if (!remote.ok) return { ok: false, reason: `could not ask origin for its main branch: ${firstLine(remote.stderr)}` };
+  const branch = remote.stdout.match(/^ref: refs\/heads\/(\S+)\s+HEAD$/m);
+  if (!branch) return { ok: false, reason: 'could not tell which branch origin ships from' };
+  const fetched = git(['fetch', '--quiet', 'origin', `refs/heads/${branch[1]}`], repoRoot);
+  if (!fetched.ok) return { ok: false, reason: `could not fetch origin: ${firstLine(fetched.stderr)}` };
+  // Judge against what was actually fetched, not what origin advertised a
+  // moment earlier: the branch can move in between.
+  const tip = git(['rev-parse', '--verify', 'FETCH_HEAD^{commit}'], repoRoot);
+  if (!tip.ok || !/^[0-9a-f]{40,64}$/.test(tip.stdout.trim())) return { ok: false, reason: 'could not read the fetched main branch' };
+  return { ok: true, branch: branch[1], tip: tip.stdout.trim() };
+}
+
+// Every path any process has open (cwd included). Any failure means we cannot
+// tell what is busy, so the caller skips all copies.
+function scanOpenPaths(lsofBin = 'lsof') {
+  const result = spawnSync(lsofBin, ['-n', '-P', '-w', '-F', 'n'], {
+    encoding: 'utf8',
+    timeout: 60000,
+    maxBuffer: 256 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    return { ok: false, reason: firstLine(result.error?.message || result.stderr || `lsof exited ${result.status}`) };
+  }
+  const paths = [];
+  for (const line of String(result.stdout || '').split('\n')) {
+    if (line.startsWith('n/')) paths.push(line.slice(1));
+  }
+  return { ok: true, paths };
+}
+
+function hasLiveProcess(realCopy, openPaths) {
+  return openPaths.some((p) => p === realCopy || p.startsWith(realCopy + path.sep));
+}
+
+function tidyMemberCopies(options = {}) {
+  const now = options.now || Date.now();
+  const dryRun = Boolean(options.dryRun);
+  const repoRoot = options.repoRoot || mainRepoRoot(options.cwd || process.cwd());
+  const result = { dryRun, worktreesDir: null, copies: [], removed: 0, kept: 0, aborted: null };
+  if (!repoRoot) {
+    result.aborted = 'not inside a git repo';
+    return result;
+  }
+  const worktreesDir = path.resolve(options.worktreesDir || defaultWorktreesDir(repoRoot));
+  result.worktreesDir = worktreesDir;
+  let realDir;
+  try {
+    realDir = fs.realpathSync(worktreesDir);
+  } catch {
+    return result;
+  }
+
+  const listed = git(['worktree', 'list', '--porcelain'], repoRoot);
+  if (!listed.ok) {
+    result.aborted = `git could not list copies: ${firstLine(listed.stderr)}`;
+    return result;
+  }
+  const copies = parseWorktreeList(listed.stdout)
+    .filter((entry) => isUnder(entry.path, worktreesDir) || isUnder(entry.path, realDir));
+
+  const keep = (copy, reason) => {
+    result.copies.push({ ...copy, action: 'kept', reason });
+    result.kept += 1;
+  };
+
+  const base = originDefaultTip(repoRoot);
+  const scan = scanOpenPaths(options.lsofBin);
+  let abortReason = null;
+  if (!base.ok) abortReason = base.reason;
+  else if (!scan.ok) abortReason = `could not check for running programs: ${scan.reason}`;
+  if (abortReason) result.aborted = abortReason;
+
+  const selfReal = (() => {
+    try { return fs.realpathSync(options.cwd || process.cwd()); } catch { return null; }
+  })();
+
+  for (const entry of copies) {
+    const copy = { name: path.basename(entry.path), path: entry.path, branch: entry.branch };
+    let realCopy;
+    try {
+      realCopy = fs.realpathSync(entry.path);
+    } catch {
+      keep(copy, 'folder is missing');
+      continue;
+    }
+    if (!isUnder(realCopy, realDir)) {
+      keep(copy, 'points outside the copies folder, left alone');
+      continue;
+    }
+    if (abortReason) {
+      keep(copy, abortReason);
+      continue;
+    }
+    if (!entry.branch) {
+      keep(copy, 'not on a branch');
+      continue;
+    }
+    const ancestor = git(['merge-base', '--is-ancestor', `refs/heads/${entry.branch}`, base.tip], repoRoot);
+    if (ancestor.status === 1) {
+      let age = '';
+      try {
+        const stat = fs.statSync(realCopy);
+        age = `, ${formatAge(now - (stat.birthtimeMs || stat.mtimeMs))}`;
+      } catch {}
+      keep(copy, `work not landed yet${age}`);
+      continue;
+    }
+    if (!ancestor.ok) {
+      keep(copy, `git could not tell if it landed: ${firstLine(ancestor.stderr)}`);
+      continue;
+    }
+    if ((selfReal && (selfReal === realCopy || isUnder(selfReal, realCopy)))
+      || hasLiveProcess(realCopy, scan.paths)) {
+      keep(copy, 'landed, but something is still running inside it');
+      continue;
+    }
+    if (dryRun) {
+      result.copies.push({ ...copy, action: 'would remove', reason: 'work landed' });
+      result.removed += 1;
+      continue;
+    }
+    const removed = git(['worktree', 'remove', entry.path], repoRoot);
+    if (!removed.ok) {
+      keep(copy, `landed, but git refused: ${firstLine(removed.stderr)}`);
+      continue;
+    }
+    const branchGone = git(['branch', '-d', entry.branch], repoRoot);
+    result.copies.push({
+      ...copy,
+      action: 'removed',
+      reason: branchGone.ok ? 'work landed, branch deleted' : `work landed, branch kept: ${firstLine(branchGone.stderr)}`,
+    });
+    result.removed += 1;
+  }
+  return result;
+}
+
+function formatTidy(result) {
+  const lines = [];
+  if (!result.worktreesDir) {
+    lines.push(`tidy: ${result.aborted || 'nothing to do'}`);
+    return lines.join('\n');
+  }
+  if (result.aborted) lines.push(`tidy: ${result.aborted}, so every copy is kept`);
+  const width = Math.max(0, ...result.copies.map((copy) => copy.action.length));
+  for (const copy of result.copies) {
+    lines.push(`${copy.action.padEnd(width)}  ${copy.name}  ${copy.reason}`);
+  }
+  const total = result.copies.length;
+  const verb = result.dryRun ? 'would remove' : 'removed';
+  lines.push(total
+    ? `tidy: ${verb} ${result.removed}, kept ${result.kept}, of ${total} ${total === 1 ? 'copy' : 'copies'} in ${result.worktreesDir}`
+    : `tidy: no member copies in ${result.worktreesDir}`);
+  return lines.join('\n');
+}
+
+module.exports = {
+  tidyMemberCopies,
+  formatTidy,
+};

package/lib/member-up.js

@@ -0,0 +1,286 @@
+'use strict';
+
+// `atris member up`: a small foreground supervisor that keeps the team
+// working. Each check it looks at every runnable member, and when one has no
+// live run and a task with a runnable check fits it, starts
+// `atris member go <name> --needs-check` so the member claims and runs that
+// task. A member with no such task stays idle; it never falls back to its
+// own mission or goal text. The clock, the spawner, the member list and the
+// task picker are passed in, so tests drive it with fake time.
+
+const { taskCheck } = require('./member-task-pick');
+const { followBoard } = require('./member-board');
+
+const CHECK_MS = 60 * 1000;
+const IDLE_CHECK_MS = 5 * 60 * 1000;
+const SUMMARY_MS = 10 * 60 * 1000;
+const IDLE_AFTER_EMPTY = 3;
+const DEFAULT_MAX = 6;
+// Exit code `member go --needs-check` uses when it found no task with a check
+// to claim (another run took it first). Not a failure, just idle.
+const IDLE_EXIT = 75;
+
+function dayOf(ms) {
+  const d = new Date(ms);
+  return `${d.getFullYear()}-${d.getMonth() + 1}-${d.getDate()}`;
+}
+
+function oneLine(text) {
+  return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+// A task only starts a member when it names a check that can be run.
+function hasRunnableCheck(task) {
+  const check = taskCheck(task);
+  return Boolean(check.command) && check.runnable;
+}
+
+// deps:
+//   listMembers() -> [{ name, parked, human, sleeping, live }]
+//   pickTask(name, takenIds) -> { id, title } | null   (looks only, never claims)
+//   spawn(name, onExit) -> any                         (onExit(code) when it ends)
+//   now() -> ms
+//   print(line)
+function createMemberUp(deps, options = {}) {
+  const max = Math.max(1, Number(options.max) || DEFAULT_MAX);
+  const dryRun = options.dryRun === true;
+  const print = deps.print || ((line) => console.log(line));
+  // only: when set, these members are the whole team for this supervisor.
+  // Nobody else is started or counted, and unknown names are skipped.
+  const only = Array.isArray(options.only) && options.only.length
+    ? new Set(options.only.map((name) => String(name).trim()).filter(Boolean))
+    : null;
+  const skippedUnknown = new Set();
+  const state = new Map();
+  const running = new Map();
+  let doneToday = 0;
+  let doneDay = dayOf(deps.now());
+  let lastSummaryAt = deps.now();
+  // Members working right now: the runs this supervisor started plus any
+  // live run started some other way. Both count toward --max.
+  let liveElsewhere = new Set();
+  const working = () => new Set([...running.keys(), ...liveElsewhere]).size;
+
+  const seat = (name) => {
+    if (!state.has(name)) state.set(name, { empty: 0, idle: false, nextCheckAt: 0 });
+    return state.get(name);
+  };
+
+  function finish(name, code, result = {}) {
+    if (!running.has(name)) return;
+    const run = running.get(name);
+    running.delete(name);
+    const now = deps.now();
+    if (dayOf(now) !== doneDay) {
+      doneDay = dayOf(now);
+      doneToday = 0;
+    }
+    const s = seat(name);
+    s.empty = 0;
+    s.nextCheckAt = 0;
+    if (code === IDLE_EXIT) {
+      s.idle = true;
+      print(idleLine(name));
+    } else if (code === 0 && result.ok !== false && run.finished?.ok !== false) {
+      doneToday += 1;
+      const changed = oneLine(result.summary || run.finished?.text.replace(/^ok\b[: ,]*/, '')
+        || run.changed || 'no change summary reported');
+      print(`${name} done ok: ${changed}`);
+    } else {
+      const reason = oneLine(result.reason || run.finished?.text.replace(/^failed\b[: ,]*/, '')
+        || (code === 0 ? 'member reported failure' : code == null ? 'run ended without a result' : `exit ${code}`));
+      print(`${name} failed: ${reason}`);
+    }
+  }
+
+  const idleLine = (name) => `${name} is idle, no task with a check`;
+
+  function progress(event) {
+    const run = running.get(event.member);
+    if (!run || Date.parse(event.at) < run.startedAt) return;
+    if (event.kind === 'finished') {
+      run.finished = event;
+      return;
+    }
+    if (event.kind !== 'step') return;
+    if (event.text.startsWith('editing ')) run.changed = event.text;
+    const time = new Date(event.at);
+    const hhmm = `${String(time.getHours()).padStart(2, '0')}:${String(time.getMinutes()).padStart(2, '0')}`;
+    print(`  ${event.member} ${hhmm}  ${oneLine(event.text)}`);
+  }
+
+  function summary() {
+    const idle = Array.from(state.values()).filter((s) => s.idle).length;
+    return `working ${working()}, idle ${idle}, done today ${doneToday}`;
+  }
+
+  // One pass over the team. Returns the members it started (or would start).
+  function check() {
+    const now = deps.now();
+    const started = [];
+    const taken = new Set(Array.from(running.values()).map((run) => run.taskId).filter(Boolean));
+    const team = deps.listMembers();
+    const members = only ? team.filter((m) => m && only.has(m.name)) : team;
+    if (only) {
+      const known = new Set(team.map((m) => m && m.name).filter(Boolean));
+      for (const name of only) {
+        if (known.has(name) || skippedUnknown.has(name)) continue;
+        skippedUnknown.add(name);
+        print(`${name} is not on the team, skipping`);
+      }
+    }
+    liveElsewhere = new Set(members.filter((m) => m && m.name && m.live).map((m) => m.name));
+    for (const member of members) {
+      const name = member && member.name;
+      if (!name || member.parked || member.human || member.sleeping) continue;
+      if (running.has(name) || member.live) continue;
+      if (working() + (dryRun ? started.length : 0) >= max) break;
+      const s = seat(name);
+      if (now < s.nextCheckAt) continue;
+      const picked = deps.pickTask(name, taken);
+      const task = picked && hasRunnableCheck(picked) ? picked : null;
+      if (!task) {
+        s.empty += 1;
+        if (!s.idle && !dryRun) print(idleLine(name));
+        s.idle = true;
+        if (s.empty >= IDLE_AFTER_EMPTY) s.nextCheckAt = now + IDLE_CHECK_MS;
+        continue;
+      }
+      const title = oneLine(task.title);
+      if (task.id) taken.add(task.id);
+      if (dryRun) {
+        print(`would start ${name} on: ${title}`);
+        started.push({ name, task });
+        continue;
+      }
+      if (s.idle) print(`${name} woke up for: ${title}`);
+      s.idle = false;
+      s.empty = 0;
+      s.nextCheckAt = 0;
+      running.set(name, { taskId: task.id || null, startedAt: now });
+      try {
+        deps.spawn(name, (code, result) => {
+          deps.flushProgress?.();
+          finish(name, code, result);
+        });
+      } catch (error) {
+        running.delete(name);
+        print(`${name} failed to start: ${oneLine(error && error.message || error)}`);
+        continue;
+      }
+      print(`${name} started on: ${title}`);
+      started.push({ name, task });
+    }
+    if (!dryRun && now - lastSummaryAt >= SUMMARY_MS) {
+      lastSummaryAt = now;
+      print(summary());
+    }
+    return started;
+  }
+
+  return {
+    check,
+    progress,
+    summary,
+    running: () => Array.from(running.keys()),
+    working,
+    max,
+    only: only ? Array.from(only) : null,
+    idle: () => Array.from(state.entries()).filter(([, s]) => s.idle).map(([name]) => name),
+  };
+}
+
+// The child's final one-line JSON carries the checked task outcome, even when
+// the CLI exits zero after releasing a failed task. Never turn that into done.
+function memberUpResult(stdout, stderr = '', signal = '') {
+  for (const line of String(stdout || '').trim().split('\n').reverse()) {
+    let result;
+    try { result = JSON.parse(line); } catch { continue; }
+    if (!result || typeof result !== 'object' || Array.isArray(result)) continue;
+    if (!result.task) {
+      if (result.mode === 'idle') return { ok: false, reason: result.reason };
+      if (result.error) return { ok: false, reason: result.error };
+      continue;
+    }
+    if (result.task.outcome !== 'review') return { ok: false, reason: result.task.reason || 'the check did not pass' };
+    return { ok: true, summary: result.work_step?.summary || '' };
+  }
+  return { ok: false, reason: signal ? `stopped by ${signal.toLowerCase()}`
+    : oneLine(stderr) || 'run ended without a checked task result' };
+}
+
+// Reads `member up` flags: --max N, --only a,b and --dry-run.
+// Returns { max, only, dryRun } or { error }.
+function parseMemberUpArgs(args = []) {
+  const list = args.map((arg) => String(arg == null ? '' : arg));
+  const valueOf = (flag) => {
+    const at = list.indexOf(flag);
+    if (at >= 0) return list[at + 1] == null ? '' : list[at + 1];
+    const inline = list.find((arg) => arg.startsWith(`${flag}=`));
+    return inline == null ? null : inline.slice(flag.length + 1);
+  };
+  const out = { max: undefined, only: null, dryRun: list.includes('--dry-run') };
+  const maxText = valueOf('--max');
+  if (maxText != null) {
+    const max = Number(maxText);
+    if (!(Number.isInteger(max) && max > 0)) return { error: '--max needs a whole number above zero.' };
+    out.max = max;
+  }
+  const onlyText = valueOf('--only');
+  if (onlyText != null) {
+    const names = onlyText.split(',').map((name) => name.trim()).filter((name) => name && !name.startsWith('-'));
+    if (!names.length) return { error: '--only needs member names, like --only navigator,executor' };
+    out.only = Array.from(new Set(names));
+  }
+  return out;
+}
+
+// Runs checks every minute until stop() is called. `sleep(ms)` must resolve
+// after ms or as soon as the returned stop fires.
+function runMemberUp(deps, options = {}) {
+  // Begin following before any child starts, so its first step cannot be lost.
+  let follower;
+  const up = createMemberUp({ ...deps, flushProgress: () => follower?.scan() }, options);
+  if (!options.dryRun) follower = followBoard({
+    dir: options.progressDir,
+    pollMs: options.progressPollMs,
+    orderByTime: true,
+    emit: (event) => up.progress(event),
+  });
+  let stopped = false;
+  let wake = null;
+  const sleep = deps.sleep || ((ms) => new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    wake = () => { clearTimeout(timer); resolve(); };
+  }));
+  const done = (async () => {
+    while (!stopped) {
+      up.check();
+      if (stopped) break;
+      await sleep(options.checkMs || CHECK_MS);
+    }
+    return up;
+  })();
+  return {
+    up,
+    done,
+    scanProgress: () => follower?.scan(),
+    stop() {
+      stopped = true;
+      follower?.stop();
+      if (wake) wake();
+    },
+  };
+}
+
+module.exports = {
+  CHECK_MS,
+  DEFAULT_MAX,
+  IDLE_CHECK_MS,
+  IDLE_EXIT,
+  SUMMARY_MS,
+  createMemberUp,
+  memberUpResult,
+  parseMemberUpArgs,
+  runMemberUp,
+};

package/lib/member-verbs.js

@@ -0,0 +1,84 @@
+'use strict';
+
+// The three plain member verbs: run, wake, sleep. This file only decides
+// which older command a verb means; the handlers that do the work are passed
+// in, so tests can check the routing without starting anything.
+//
+//   atris member run "<job>"          picks the member and runs the job
+//   atris member run <name> "<job>"   runs that member, as before
+//   atris member wake 5               keeps up to 5 members working
+//   atris member wake a b             keeps just a and b working
+//   atris member wake a               one wake for a, as before (--keep keeps it working)
+
+const fs = require('fs');
+const path = require('path');
+
+const SLUG = /^[a-z0-9][a-z0-9._-]*$/i;
+const IGNITE_FLAGS = ['--ignite', '--wait', '--sync'];
+
+const WAKE_USAGE = [
+  'wake members three ways:',
+  '  atris member wake 5                    keep up to 5 members working',
+  '  atris member wake navigator executor   keep just these members working',
+  '  atris member wake navigator            one work step now (add --keep to keep it working)',
+];
+
+// A member is a folder in atris/team with a MEMBER.md (or an older flat
+// <name>.md card).
+function isTeamMember(root, name) {
+  const clean = String(name == null ? '' : name).trim();
+  if (!SLUG.test(clean)) return false;
+  const team = path.join(root, 'atris', 'team');
+  return fs.existsSync(path.join(team, clean, 'MEMBER.md')) || fs.existsSync(path.join(team, `${clean}.md`));
+}
+
+// The words before the first flag.
+function leadingWords(args) {
+  const words = [];
+  for (const arg of args) {
+    const text = String(arg == null ? '' : arg);
+    if (text.startsWith('-')) break;
+    words.push(text);
+  }
+  return words;
+}
+
+// handlers: { root, run(name, ...args), dispatch(...args) }
+function memberRunVerb(args, handlers) {
+  const first = args[0];
+  if (first == null || String(first).startsWith('-') || isTeamMember(handlers.root, first)
+    || (handlers.aliasOf && isTeamMember(handlers.root, handlers.aliasOf(first)))) {
+    return handlers.run(first, ...args.slice(1));
+  }
+  const ignite = args.some((arg) => IGNITE_FLAGS.includes(arg));
+  return handlers.dispatch(...args, ...(ignite ? [] : ['--ignite']));
+}
+
+// handlers: { wake(name, ...args), up(...args), print(line) }
+async function memberWakeVerb(args, handlers) {
+  const print = handlers.print || ((line) => console.log(line));
+  if (!args.length) {
+    for (const line of WAKE_USAGE) print(line);
+    return { ok: true, usage: true };
+  }
+  const words = leadingWords(args);
+  const flags = args.slice(words.length);
+  const keep = flags.includes('--keep');
+  const rest = flags.filter((flag) => flag !== '--keep');
+  if (words.length === 1 && /^[1-9]\d*$/.test(words[0])) {
+    return handlers.up('--max', words[0], ...rest);
+  }
+  if (words.length >= 2 || (words.length === 1 && keep)) {
+    return handlers.up('--only', words.join(','), ...rest);
+  }
+  const result = await handlers.wake(args[0], ...args.slice(1));
+  if (words.length === 1 && !args.includes('--json')) {
+    print(`to keep ${words[0]} working: atris member wake ${words[0]} --keep`);
+  }
+  return result;
+}
+
+module.exports = {
+  memberRunVerb,
+  memberWakeVerb,
+};

package/lib/runner-command.js

@@ -386,6 +386,34 @@ function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
   return cmd;
 }
 
+// Whether the installed codex prints JSONL events and can write its final
+// answer to a file. Asked once per program; an older codex without the flags
+// keeps today's plain launch.
+const codexJsonSupport = new Map();
+function codexSupportsJsonEvents(bin) {
+  if (codexJsonSupport.has(bin)) return codexJsonSupport.get(bin);
+  let supported = false;
+  try {
+    const { spawnSync } = require('child_process');
+    const res = spawnSync(bin, ['exec', '--help'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const help = `${res.stdout || ''}${res.stderr || ''}`;
+    supported = res.status === 0 && /--json\b/.test(help) && /--output-last-message\b/.test(help);
+  } catch {}
+  codexJsonSupport.set(bin, supported);
+  return supported;
+}
+
+// The codex launch with live JSONL events on stdout and the final answer in
+// lastMessageFile, or null when this runner is not a codex exec that takes them.
+function codexJsonEventsCommand(cmd, lastMessageFile) {
+  const bin = resolveClaudeRunnerBin();
+  if (ownModelsOnlyEngineForBin(bin) !== 'codex') return null;
+  const lead = `${shellWord(bin)} exec`;
+  if (!String(cmd).startsWith(`${lead} `)) return null;
+  if (!codexSupportsJsonEvents(bin)) return null;
+  return `${lead} --json --output-last-message ${shellWord(lastMessageFile)}${cmd.slice(lead.length)}`;
+}
+
 // Whether this engine's launch can carry a pinned model, and which effort
 // words it takes. The roster checks both when it reads a line.
 function engineTakesModel(engineId) {
@@ -401,6 +429,7 @@ function engineEffortLevels(engineId) {
 
 module.exports = {
   EFFORT_WORDS,
+  codexJsonEventsCommand,
   engineTakesModel,
   engineEffortLevels,
   DEFAULT_CLAUDE_RUNNER_MODEL,

package/lib/task-db.js

@@ -537,7 +537,11 @@ function getTask(db, id) {
     WHERE id = ?
   `).get(id);
   if (!row) return null;
-  return { ...row, metadata: row.metadata ? safeJSON(row.metadata) : null };
+  const metadata = row.metadata ? safeJSON(row.metadata) : null;
+  // Stored metadata that does not parse to an object is flagged, so readers
+  // that must fail closed can tell it apart from no metadata at all.
+  const unreadable = Boolean(row.metadata) && (!metadata || typeof metadata !== 'object' || Array.isArray(metadata));
+  return { ...row, metadata, ...(unreadable ? { metadata_unreadable: true } : {}) };
 }
 
 // Atomic claim. Returns { claimed: true, row } only if THIS call won the row.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.68.9",
+  "version": "3.69.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {