atris 3.68.8 → 3.69.0

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,
+};

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,
+};