atris 3.69.0 → 3.71.0

package/lib/member-board.js

@@ -97,6 +97,27 @@ function currentRun(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;
@@ -112,9 +133,12 @@ function memberRow(name, text, now) {
   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,
+    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.
@@ -129,25 +153,62 @@ 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 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 || '-',
@@ -155,7 +216,7 @@ function renderBoard(rows, dir = progressDir(), hidden = 0) {
     r.job || '-',
     r.step || '-',
   ]);
-  const head = ['member', 'state', 'alive', 'engine', 'running for', 'ago', 'job', 'last 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)];
@@ -295,6 +356,8 @@ const ENGINE_PROGRAMS = Object.freeze({
   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)], {
@@ -326,7 +389,10 @@ function pidRunsEngine(pid, engine, deps = {}, startedLineAt = null, member = ''
   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 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;
@@ -335,7 +401,10 @@ function pidRunsEngine(pid, engine, deps = {}, startedLineAt = null, member = ''
   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;
+  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 };
 }
 
@@ -381,11 +450,18 @@ async function memberStopCommand(name) {
 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 });
+    // Mark where every log ends before reading the snapshot, so a line written
+    // while the snapshot prints is streamed after it instead of lost.
+    const early = [];
+    let send = (event) => early.push(event);
+    const follower = followBoard({ dir, emit: (event) => { if (!only || only.includes(event.member)) send(event); } });
+    write({ kind: 'snapshot', at: new Date().toISOString(), dir, members: readBoard({ dir, all, asleep: sleepingHere(), only }) });
+    send = write;
+    early.forEach(write);
     // Runs until ctrl-c or the reader closes the pipe.
     return new Promise((resolve) => {
       const done = () => { follower.stop(); resolve(); };
@@ -394,11 +470,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);
   };
@@ -417,5 +493,5 @@ function memberBoardCommand(...args) {
 
 module.exports = {
   readBoard, renderBoard, memberRow, ago, progressEvent, followBoard, memberBoardCommand,
-  parseStarted, isAlive, stopMember, memberStopCommand,
+  parseStarted, teamHere, isAlive, stopMember, memberStopCommand,
 };

package/lib/member-map-fold.js

@@ -0,0 +1,126 @@
+'use strict';
+
+// Member changes save map notes as their own small files under
+// atris/refs/map-notes.d/ instead of editing atris/refs/MAP-NOTES.md, so two
+// changes never clash on the shared map. Once an hour the autoland tick folds
+// those files into MAP-NOTES.md on the main branch and removes them, in one
+// commit built without touching any checkout. A push that loses a race with
+// another landing is dropped; the next hour tries again from the new main.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const NOTES_FILE = 'atris/refs/MAP-NOTES.md';
+const DROP_DIR = 'atris/refs/map-notes.d';
+const FOLD_EVERY_MS = 60 * 60 * 1000;
+
+function git(args, cwd, extraEnv = {}) {
+  const res = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: 120000,
+    env: { ...process.env, ...extraEnv, GIT_NO_REPLACE_OBJECTS: '1' },
+  });
+  return {
+    ok: res.status === 0,
+    stdout: String(res.stdout || ''),
+    stderr: String(res.stderr || res.error?.message || '').trim(),
+  };
+}
+
+function foldDue(lastAt, now = Date.now()) {
+  const last = Date.parse(lastAt || '');
+  return !Number.isFinite(last) || now - last >= FOLD_EVERY_MS;
+}
+
+const isHeading = (line) => /^## \S/.test(line);
+const trimEnd = (text) => String(text || '').replace(/\r\n/g, '\n').replace(/\s+$/, '');
+
+// Fold drop texts into the notes text. A drop that opens with a "## " heading
+// already in the notes adds its new lines at the end of that section; any
+// other drop is added at the end of the file as written. A drop whose lines
+// are all already there adds nothing.
+function foldNotesText(notes, drops) {
+  const lines = trimEnd(notes) ? trimEnd(notes).split('\n') : [];
+  let added = 0;
+  for (const drop of drops) {
+    const body = trimEnd(drop.text).split('\n');
+    while (body.length && !body[0].trim()) body.shift();
+    if (!body.length) continue;
+    const at = isHeading(body[0]) ? lines.findIndex((l) => l.trim() === body[0].trim()) : -1;
+    if (at >= 0) {
+      let end = lines.findIndex((l, i) => i > at && isHeading(l));
+      if (end < 0) end = lines.length;
+      const seen = new Set(lines.slice(at, end).map((l) => l.trim()));
+      const fresh = body.slice(1).filter((l) => l.trim() && !seen.has(l.trim()));
+      if (!fresh.length) continue;
+      while (end > at + 1 && !lines[end - 1].trim()) end--;
+      lines.splice(end, 0, ...fresh);
+      added += fresh.length;
+    } else {
+      const seen = new Set(lines.map((l) => l.trim()));
+      const content = body.filter((l) => l.trim());
+      if (content.every((l) => seen.has(l.trim()))) continue;
+      if (lines.length) lines.push('');
+      lines.push(...body);
+      added += content.length;
+    }
+  }
+  return { text: lines.length ? `${lines.join('\n')}\n` : '', added };
+}
+
+function mainBranch(root, remote) {
+  const head = git(['symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`], root).stdout.trim();
+  return head.startsWith(`${remote}/`) ? head.slice(remote.length + 1) : 'master';
+}
+
+// Fold every drop file on the main branch into the shared map notes and push
+// the result. Returns what happened; never throws for an ordinary miss.
+function foldMapNotesOnMain(root, { base = '', remote = 'origin', push = true } = {}) {
+  base = base || mainBranch(root, remote);
+  const remoteRef = `refs/remotes/${remote}/${base}`;
+  const fetched = git(['fetch', '-q', remote, `+refs/heads/${base}:${remoteRef}`], root);
+  if (!fetched.ok) return { folded: 0, reason: 'main_unreadable', detail: fetched.stderr.split('\n')[0] };
+  const baseSha = git(['rev-parse', remoteRef], root).stdout.trim();
+  if (!/^[0-9a-f]{40,64}$/.test(baseSha)) return { folded: 0, reason: 'main_unreadable' };
+
+  const listed = git(['ls-tree', '-r', '--name-only', baseSha, '--', `${DROP_DIR}/`], root);
+  const files = listed.stdout.split('\n').filter((f) => f.endsWith('.md')).sort();
+  if (!files.length) return { folded: 0, reason: 'nothing_to_fold', base: baseSha };
+
+  const drops = [];
+  for (const file of files) {
+    const blob = git(['cat-file', 'blob', `${baseSha}:${file}`], root);
+    if (!blob.ok) return { folded: 0, reason: 'drop_unreadable', detail: file };
+    drops.push({ file, text: blob.stdout });
+  }
+  const current = git(['cat-file', 'blob', `${baseSha}:${NOTES_FILE}`], root);
+  const { text, added } = foldNotesText(current.ok ? current.stdout : '', drops);
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-map-fold-'));
+  try {
+    const index = { GIT_INDEX_FILE: path.join(tmp, 'index') };
+    const notesPath = path.join(tmp, 'notes');
+    fs.writeFileSync(notesPath, text);
+    const blob = git(['hash-object', '-w', notesPath], root).stdout.trim();
+    const built = git(['read-tree', baseSha], root, index).ok
+      && /^[0-9a-f]{40,64}$/.test(blob)
+      && git(['update-index', '--add', '--cacheinfo', `100644,${blob},${NOTES_FILE}`], root, index).ok
+      && git(['update-index', '--force-remove', '--', ...files], root, index).ok;
+    const tree = built ? git(['write-tree'], root, index).stdout.trim() : '';
+    const message = `Fold ${files.length} map ${files.length === 1 ? 'note' : 'notes'} from member changes into the shared map`;
+    const commit = tree ? git(['commit-tree', tree, '-p', baseSha, '-m', message], root).stdout.trim() : '';
+    if (!/^[0-9a-f]{40,64}$/.test(commit)) return { folded: 0, reason: 'commit_failed' };
+    if (!push) return { folded: files.length, added, sha: commit, pushed: false, files };
+    const pushed = git(['push', '-q', remote, `${commit}:refs/heads/${base}`], root);
+    if (!pushed.ok) return { folded: 0, reason: 'push_rejected', detail: pushed.stderr.split('\n')[0], sha: commit };
+    git(['update-ref', remoteRef, commit], root);
+    return { folded: files.length, added, sha: commit, pushed: true, files };
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+module.exports = { NOTES_FILE, DROP_DIR, FOLD_EVERY_MS, foldDue, foldNotesText, foldMapNotesOnMain };

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 {}
 }