atris 3.70.0 → 3.71.0

package/commands/compile.js

@@ -468,14 +468,25 @@ function executeBuild(root, name, options = {}) {
     const cmd = cmdOverride || buildRunnerCommand({ promptFile: tmpFile, allowedTools: 'Read,Write,Edit,Glob,Grep' });
     const env = { ...process.env };
     delete env.CLAUDECODE;
-    execSync(cmd, {
-      cwd: root,
-      encoding: 'utf8',
-      timeout,
-      stdio: verbose ? 'inherit' : 'pipe',
-      maxBuffer: 10 * 1024 * 1024,
-      env,
-    });
+    // Machine memory and load at both ends of the build, so one killed with
+    // SIGKILL says whether the machine was short on memory.
+    const endResource = require('../lib/engine-resource').startEngineRun(root, { engine: 'runner', task: `compile ${name}` });
+    try {
+      execSync(cmd, {
+        cwd: root,
+        encoding: 'utf8',
+        timeout,
+        stdio: verbose ? 'inherit' : 'pipe',
+        maxBuffer: 10 * 1024 * 1024,
+        env,
+      });
+    } catch (err) {
+      // A kill leaves no report of its own, so the error names the likely cause.
+      const end = endResource(err);
+      if (end && end.cause && err instanceof Error) err.message = `${err.message}; ${end.cause}`;
+      throw err;
+    }
+    endResource();
   } finally {
     try { fs.unlinkSync(tmpFile); } catch {}
   }

package/commands/doctor.js

@@ -88,6 +88,48 @@ function installWarnings(packageRoot) {
   return warnings;
 }
 
+// Outside coding tools a member can run on. The built-in tool (ax) ships
+// with atris and only needs a sign-in, so it is counted through auth.
+const MEMBER_TOOL_BINS = ['claude', 'codex', 'cursor-agent', 'opencode', 'devin', 'grok', 'agy'];
+
+function teamMembers(workspaceRoot) {
+  const teamDir = path.join(workspaceRoot, 'atris', 'team');
+  let entries = [];
+  try { entries = fs.readdirSync(teamDir, { withFileTypes: true }); } catch { return []; }
+  return entries
+    .filter((entry) => entry.isDirectory() && !entry.name.startsWith('_'))
+    .filter((entry) => fs.existsSync(path.join(teamDir, entry.name, 'MEMBER.md')))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+// What a member run needs before it can start: someone on the team, git for
+// its own copy of the work, and a coding tool to think with. One fix line
+// names the first missing piece.
+function memberReadiness(workspaceRoot, auth, probe) {
+  const members = teamMembers(workspaceRoot);
+  const git_installed = probe('git');
+  const git_repo = fs.existsSync(path.join(workspaceRoot, '.git'));
+  const tools = MEMBER_TOOL_BINS.filter((bin) => probe(bin));
+  const built_in_tool = Boolean(auth && auth.signed_in);
+  const has_tool = tools.length > 0 || built_in_tool;
+  let next = null;
+  if (!members.length) next = 'run atris init to add a team to this folder.';
+  else if (!git_installed) next = 'install git so members can work on their own copy.';
+  else if (!git_repo) next = 'run git init here so members can work on their own copy.';
+  else if (!has_tool) next = 'install claude code or codex, or run atris login to use the built-in tool.';
+  return {
+    ready: next === null,
+    members: members.length,
+    member_names: members,
+    git_installed,
+    git_repo,
+    tools,
+    built_in_tool,
+    next,
+  };
+}
+
 function collectDoctor(options = {}) {
   const packageRoot = options.packageRoot || path.join(__dirname, '..');
   const node = parseNodeVersion(options.nodeVersion || process.version);
@@ -100,6 +142,8 @@ function collectDoctor(options = {}) {
   const version_line = formatCliVersionLine(version, packageRoot);
   const install_git = inspectInstallGitState(packageRoot);
   const warnings = installWarnings(packageRoot);
+  const probe = options.binInstalled || require('../lib/engine-registry').binInstalled;
+  const members = memberReadiness(workspace_root, auth, probe);
   return {
     ok: true,
     action: 'doctor',
@@ -125,6 +169,7 @@ function collectDoctor(options = {}) {
       branch: install_git.branch || null,
       head: install_git.head || null,
     },
+    members,
     warnings,
   };
 }
@@ -140,6 +185,16 @@ function renderDoctor(payload) {
   lines.push(`workspace: ${payload.workspace_root}`);
   lines.push(`cli runnable: ${payload.cli_runnable ? 'yes' : 'no'}`);
   lines.push(`public bin: ${payload.bin.public_bin} (${payload.bin.shim ? `${payload.bin.shim_bytes} byte shim` : 'not a shim'})`);
+  const m = payload.members;
+  if (m) {
+    const toolNames = m.tools.concat(m.built_in_tool ? ['built-in'] : []);
+    lines.push('');
+    lines.push(`members: ${m.ready ? 'ready' : 'not ready yet'}`);
+    lines.push(`  team: ${m.members ? `${m.members} member${m.members === 1 ? '' : 's'}` : 'none'}`);
+    lines.push(`  git: ${!m.git_installed ? 'not installed' : (m.git_repo ? 'yes' : 'installed, but this folder is not a git repo')}`);
+    lines.push(`  coding tool: ${toolNames.length ? toolNames.join(', ') : 'none'}`);
+    if (m.next) lines.push(`  next: ${m.next}`);
+  }
   if (payload.warnings && payload.warnings.length) {
     lines.push('');
     for (const warning of payload.warnings) lines.push(`warning: ${warning}`);
@@ -156,6 +211,7 @@ function doctorCommand(args = [], options = {}) {
     console.log('Usage: atris doctor [--json]');
     console.log('');
     console.log('Reports node version, task-support (22+), auth, workspace root, and whether the CLI can run.');
+    console.log('Also checks what members need: a team, git, and a coding tool.');
     console.log('Public install entry is bin/atris (tiny POSIX shim) -> bin/atris.js.');
     return 0;
   }
@@ -171,4 +227,6 @@ function doctorCommand(args = [], options = {}) {
 
 module.exports = {
   doctorCommand,
+  collectDoctor,
+  renderDoctor,
 };

package/commands/dream.js

@@ -234,6 +234,20 @@ function dreamModels() {
 function defaultDreamRunner({ prompt, model, cwd, timeoutMs = DREAM_TIMEOUT_MS }) {
   return new Promise((resolve) => {
     const bin = (RUNNER_PROFILE_DEFS.haiku && RUNNER_PROFILE_DEFS.haiku.bin) || 'claude';
+    // Machine memory and load at both ends of the launch, so one killed with
+    // SIGKILL says whether the machine was short on memory.
+    const endResource = require('../lib/engine-resource').startEngineRun(cwd, { engine: path.basename(bin), task: 'dream' });
+    // The child does not throw, so a failure is passed in the thrown shape.
+    const finish = (result, signal = null) => {
+      const failed = !result.ok;
+      const end = endResource(failed ? {
+        code: timedOut ? 'ETIMEDOUT' : '',
+        signal,
+        stderr: result.stderr,
+        message: result.error || `model exited ${result.exitCode}`,
+      } : null);
+      resolve({ ...result, ...(signal ? { signal } : {}), ...(end && end.cause && !timedOut ? { cause: end.cause } : {}) });
+    };
     const proc = spawn(bin, ['-p', prompt, '--model', model], {
       cwd,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -247,13 +261,13 @@ function defaultDreamRunner({ prompt, model, cwd, timeoutMs = DREAM_TIMEOUT_MS }
     }, timeoutMs);
     proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
     proc.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
-    proc.on('close', (code) => {
+    proc.on('close', (code, signal) => {
       clearTimeout(timer);
-      resolve({ ok: code === 0 && !timedOut, stdout, stderr, exitCode: code, timedOut });
+      finish({ ok: code === 0 && !timedOut, stdout, stderr, exitCode: code, timedOut }, signal);
     });
     proc.on('error', (error) => {
       clearTimeout(timer);
-      resolve({ ok: false, error: error.message, stdout, stderr, timedOut });
+      finish({ ok: false, error: error.message, stdout, stderr, timedOut });
     });
   });
 }
@@ -262,6 +276,7 @@ function attemptFailureReason(result) {
   if (result && result.garbled) return 'could not read dream cards';
   if (result && result.timedOut) return 'model timed out';
   if (result && result.error) return 'model could not start';
+  if (result && result.signal) return `model stopped by ${result.signal}${result.cause ? `; ${result.cause}` : ''}`;
   if (result && result.exitCode) return 'model stopped early';
   return 'model did not answer';
 }

package/commands/engine.js

@@ -1891,7 +1891,7 @@ const PROBE_PROMPT = 'Reply with exactly the two characters: OK';
 // answer on 2026-07-02. 30s produced a false FAIL on a healthy engine.
 const PROBE_DEFAULT_TIMEOUT_MS = 120000;
 
-function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS } = {}) {
+function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS, root = process.cwd() } = {}) {
   const def = RUNNER_PROFILE_DEFS[name];
   if (!binInstalled(def.bin)) {
     return {
@@ -1917,11 +1917,15 @@ function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS } = {}) {
     if (prevProfile === undefined) delete process.env.ATRIS_RUNNER_PROFILE;
     else process.env.ATRIS_RUNNER_PROFILE = prevProfile;
   }
+  // Machine memory and load at both ends of the probe, so one killed with
+  // SIGKILL says whether the machine was short on memory.
+  const endResource = require('../lib/engine-resource').startEngineRun(root, { engine: name, task: 'engine probe' });
   const start = Date.now();
   let res;
   try {
     res = spawnSync('sh', ['-c', cmd], { encoding: 'utf8', timeout });
   } catch (err) {
+    endResource(err);
     fs.rmSync(tmpDir, { recursive: true, force: true });
     return {
       engine: name,
@@ -1935,6 +1939,15 @@ function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS } = {}) {
     };
   }
   const durationMs = Date.now() - start;
+  // spawnSync does not throw, so a failure is passed in the thrown shape.
+  const launchFailed = res.error || res.signal || res.status !== 0;
+  const end = endResource(launchFailed ? {
+    code: res.error && res.error.code,
+    signal: res.signal,
+    stderr: res.stderr,
+    message: res.error ? res.error.message : `exit ${res.status}`,
+  } : null);
+  const cause = end && end.cause ? `; ${end.cause}` : '';
   fs.rmSync(tmpDir, { recursive: true, force: true });
   const stdout = res.stdout || '';
   const stderr = res.stderr || '';
@@ -1954,7 +1967,7 @@ function probeEngine(name, { timeout = PROBE_DEFAULT_TIMEOUT_MS } = {}) {
     reason,
     message: ok
       ? 'responded OK'
-      : (timedOut ? `no reply within ${timeout}ms` : `did not reply OK (exit ${res.status}, signal ${res.signal})`),
+      : (timedOut ? `no reply within ${timeout}ms` : `did not reply OK (exit ${res.status}, signal ${res.signal})${cause}`),
     stdout,
     stderr,
     durationMs,
@@ -2032,7 +2045,7 @@ function runBenchCommand(args, root, deps = {}) {
     }
   }
 
-  const probeOpts = {};
+  const probeOpts = { root };
   if (timeout) probeOpts.timeout = timeout;
 
   const results = [];
@@ -2154,7 +2167,7 @@ function runEngineTest(targets, { json, root } = {}) {
       return 1;
     }
   }
-  const results = enginesToTest.map((name) => probeEngine(name));
+  const results = enginesToTest.map((name) => probeEngine(name, { root }));
   const failures = results.filter((r) => !r.pass);
   const passed = results.length - failures.length;
   // A live probe is the freshest health evidence there is: write it back so
@@ -2314,6 +2327,132 @@ function shorthandModelError(engine, args, root) {
   }
 }
 
+function formatAgentAge(seconds) {
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days) return `${days}d ${hours % 24}h`;
+  if (hours) return `${hours}h ${minutes % 60}m`;
+  return `${minutes}m`;
+}
+
+// atris engine sweep: list ssh-agents that engine shells started and left
+// behind. With --apply it rechecks each one and stops it with SIGTERM, and
+// writes a parent gone end line for each run whose parent process is gone.
+function runEngineSweepCommand(args, root, deps = {}) {
+  const { readSshAgents, findLeakedSshAgents, findAgentStartLines, agentStartLineText, stopLeakedSshAgents, closeLostRuns, readResourceHistory, leakGrowthNote, LEAK_MIN_AGE_SEC } = require('../lib/engine-resource');
+  const read = deps.read || readSshAgents;
+  const { agents, referenced, unread = [] } = read();
+  const uid = deps.uid !== undefined ? deps.uid : process.getuid();
+  const leaked = findLeakedSshAgents(agents, { referenced, uid });
+  const apply = args.includes('--apply');
+  const result = apply
+    ? stopLeakedSshAgents(root, leaked, { read, uid, ...(deps.kill ? { kill: deps.kill } : {}), ...(deps.now ? { now: deps.now } : {}) })
+    : { stopped: [], failed: [], skipped: [] };
+  result.unread = [...new Set([...unread, ...(result.unread || [])])];
+  const scanWarning = result.unread.length
+    ? `could not read the ${result.unread.join(' or the ')} for every process, so some ssh-agents could not be checked; the leak count may be incomplete`
+    : null;
+  result.closed_runs = [];
+  if (apply) {
+    // Agents may already be stopped here, so a failed close is reported
+    // beside them rather than thrown away with the whole report.
+    try {
+      result.closed_runs = closeLostRuns(root, deps.now ? { now: deps.now } : {});
+    } catch (err) {
+      result.close_error = String((err && err.message) || err).slice(0, 200);
+    }
+  }
+  // A test run reads only the home it was handed, never the real one.
+  const startLines = leaked.length && (deps.home || !process.env.NODE_TEST_CONTEXT)
+    ? findAgentStartLines(deps.home ? { home: deps.home } : {})
+    : [];
+  const code = result.failed.length || result.close_error ? 1 : 0;
+  if (args.includes('--json')) {
+    console.log(JSON.stringify({ running: agents.length, leaked, unread, ...result, agent_start_lines: startLines, history: readResourceHistory(root) }, null, 2));
+    return code;
+  }
+  const plural = (n, word) => `${n} ${word}${n === 1 ? '' : 's'}`;
+  if (apply) {
+    const lines = [`stopped ${plural(result.stopped.length, 'leaked ssh-agent')}`];
+    const replaced = (result.replaced || []).length;
+    const otherSkipped = result.skipped.length - replaced;
+    if (replaced) lines.push(`${replaced} skipped because ${replaced === 1 ? 'a younger ssh-agent now has' : 'younger ssh-agents now have'} the same process number`);
+    if (otherSkipped) lines.push(`${otherSkipped} skipped because they were in use or gone on the recheck`);
+    for (const { pid, code: reason } of result.failed) lines.push(`could not stop pid ${pid}: ${reason}`);
+    if (result.close_error) lines.push(`could not close lost runs, so unfinished records may remain: ${result.close_error}`);
+    else lines.push(`closed ${plural(result.closed_runs.length, 'run')} whose parent is gone`);
+    if (scanWarning) lines.push(scanWarning);
+    console.log(lines.join('\n'));
+    return code;
+  }
+  const shown = 20;
+  const history = readResourceHistory(root);
+  const lines = [
+    `${plural(agents.length, 'ssh-agent')} running, ${leaked.length} ${leaked.length === 1 ? 'looks' : 'look'} leaked${leakGrowthNote(history.first_day_leak_reading, leaked.length)}`
+      + ` (no parent, older than ${LEAK_MIN_AGE_SEC / 60} min, not in use by any live shell)`,
+    ...leaked.slice(0, shown).map((agent) => `  pid ${String(agent.pid).padEnd(6)} ${formatAgentAge(agent.age_sec)}`),
+  ];
+  if (leaked.length > shown) lines.push(`  and ${leaked.length - shown} more`);
+  lines.push(...startLines.map(agentStartLineText));
+  if (scanWarning) lines.push(scanWarning);
+  lines.push(leaked.length ? 'nothing was stopped. run atris engine sweep --apply to stop them.' : 'nothing was stopped.');
+  lines.push('', ...resourceHistoryLines(history));
+  console.log(lines.join('\n'));
+  return 0;
+}
+
+function utcMinute(at) {
+  return `${String(at || '').slice(0, 16).replace('T', ' ')} UTC`;
+}
+
+// What the resource log says about past runs: the newest sweep, runs with no
+// end, the newest run that failed without being killed and why, the newest
+// SIGKILL and its likely cause, and how many SIGKILLs came with low memory.
+function resourceHistoryLines(history) {
+  const { errorReason } = require('../lib/engine-resource');
+  const lines = [];
+  if (history.read_error) {
+    lines.push(`could not read the engine run log: ${history.read_error}, so past sweeps, kills, and errors are unknown`);
+    return lines;
+  }
+  const sweep = history.last_sweep;
+  lines.push(sweep
+    ? `last sweep: ${utcMinute(sweep.at)}, stopped ${(sweep.stopped || []).length}`
+    : 'no sweep recorded yet');
+  const started = history.last_open;
+  if (started) {
+    const unrecorded = history.open_runs - history.parent_gone - history.still_running;
+    const parts = [
+      history.parent_gone && `${history.parent_gone} whose parent is gone`,
+      history.still_running && `${history.still_running} still running`,
+      unrecorded && `${unrecorded} from before parents were recorded`,
+    ].filter(Boolean);
+    lines.push(`${history.open_runs} run${history.open_runs === 1 ? '' : 's'} started with no end recorded: ${parts.join(', ')};`
+      + ` newest: ${started.engine || 'engine'} on ${started.task || 'an unnamed task'} at ${utcMinute(started.at)}`);
+  }
+  const failed = history.last_error;
+  if (failed) {
+    lines.push(`last engine error: ${failed.engine || 'engine'} on ${failed.task || 'an unnamed task'} at ${utcMinute(failed.at)}: ${errorReason(failed)}`);
+  }
+  const kill = history.last_kill;
+  if (!kill) {
+    lines.push('no engine run has ended in SIGKILL');
+    return lines;
+  }
+  const killLine = (entry) => {
+    const free = Number.isFinite(entry.free_pct) ? `, ${entry.free_pct}% memory free` : '';
+    return `${entry.engine || 'engine'} on ${entry.task || 'an unnamed task'} at ${utcMinute(entry.at)}, ${entry.cause}${free}`;
+  };
+  lines.push(`last SIGKILL: ${killLine(kill)}`);
+  // Timeouts can pile up after a crash; still name the newest kill that was not one.
+  const other = history.last_other_kill;
+  if (other && other !== kill) lines.push(`last SIGKILL not at a time limit: ${killLine(other)}`);
+  const timeLimit = history.time_limit_kills ? `, ${history.time_limit_kills} at their time limit` : '';
+  lines.push(`${history.low_memory_kills} of ${history.kills} SIGKILL${history.kills === 1 ? '' : 's'} ended with machine memory low${timeLimit}`);
+  return lines;
+}
+
 function engineCommand(args = [], deps = {}) {
   const root = deps.root || process.cwd();
   const dispatch = deps.engineDispatch || runDispatchCommand;
@@ -2323,6 +2462,9 @@ function engineCommand(args = [], deps = {}) {
   if ((args[0] || '').trim() === 'watch') {
     return runEngineWatchCommand(args.slice(1), root, deps.engineWatch || {});
   }
+  if ((args[0] || '').trim() === 'sweep') {
+    return runEngineSweepCommand(args.slice(1), root, deps.engineSweep || {});
+  }
   if ((args[0] || '').trim() === 'validate') {
     return runEngineValidateCommand(args.slice(1), root, deps.engineValidate || {});
   }
@@ -2406,7 +2548,7 @@ function engineCommand(args = [], deps = {}) {
     if (sub === 'help' || args.includes('--help') || args.includes('-h')) {
       console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
       console.log('\n  long read-only asks: atris engine ask "..." --engine agy --timeout <seconds>\n                           quick asks default to 120 seconds; explicit jobs allow up to 3600\n                           follow live work with atris engine watch latest');
-      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n                           flags a model with a newer version on this machine, or a pin not proven in 30 days\n                           (a landed run, or "verified 2026-09-30" on its line, proves it)\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine roster --runs [job]\n                           the last 20 runs, newest first, with tool, model, time, and outcome\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--prep <job>] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --promote "<tool> [model]" | --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --promote moves one of its workers to the top as written;\n                           --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --prep search has that job read the task first and hand this worker a short brief;\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job;\n                           notes always answers: its roster pick, else agy then haiku\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+      console.log('\n  atris engine            roster + current default\n  atris engine roster [--json] show every job and its workers in order: search, build, review, and your own\n                           flags a model with a newer version on this machine, or a pin not proven in 30 days\n                           (a landed run, or "verified 2026-09-30" on its line, proves it)\n  atris engine roster confirm renew every dated worker for 30 days\n  atris engine roster session [clear]\n                           show or drop the roster changes for this shell only\n  atris engine roster --available\n                           tools on this machine and the models each one offers\n  atris engine roster --runs [job]\n                           the last 20 runs, newest first, with tool, model, time, and outcome\n  atris engine assign <job> <tool> [--like <kind>] [--model <m>] [--effort <level>] [--max "20 min"] [--prep <job>] [--backup "<tool> [model]"] [--days <n>] [--add] [--session | --everywhere]\n  atris engine assign <job> --promote "<tool> [model]" | --remove <tool> | --clear [--session | --everywhere]\n                           sets the lead worker of the job; --promote moves one of its workers to the top as written;\n                           --add puts one more at the end; jobs: search, build, review,\n                           or your own like "small build" (--like search|build|review when the name does not say);\n                           --prep search has that job read the task first and hand this worker a short brief;\n                           --everywhere is for all projects; --session is this shell only (set ATRIS_ROSTER_SESSION=<name>)\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json [--all] full registry: default + engines with tier, roles, fallback, health (--all includes hidden engines)\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> or <job> [--json]\n                           choose the best ready engine for navigator|executor|validator or a roster job;\n                           notes always answers: its roster pick, else agy then haiku\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine bench [names...] [--runs N]\n                           ranked latency scoreboard of engine passes\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine sweep [--apply] [--json]\n                           list ssh-agents that engine shells left running; --apply rechecks and stops them\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
       return 0;
     }
     if (isFreshWorkspace(root)) {

package/commands/improve.js

@@ -535,13 +535,17 @@ function collectImproveVitals(options = {}, deps = {}) {
     const collect = deps.collectRevisionSignals || collectRevisionSignals;
     const rev = collect(root, { days: 14, now: nowMs });
     const landingsPhrase = `${countWord(rev.landings)} landing${rev.landings === 1 ? '' : 's'} this fortnight`;
-    const fixPhrase = `${countWord(rev.revised)} needed a human fix`;
+    const fixed = Number.isFinite(rev.fixed) ? rev.fixed : rev.revised;
+    const fixPhrase = `${countWord(fixed)} needed a human fix`;
+    const coachPhrase = rev.coached ? `, ${countWord(rev.coached)} got your coaching` : '';
     guarantee = {
       days: rev.days,
       landings: rev.landings,
       revised: rev.revised,
+      fixed,
+      coached: rev.coached || 0,
       rate: rev.rate,
-      sentence: plainSentence(`${landingsPhrase}, ${fixPhrase}.`),
+      sentence: plainSentence(`${landingsPhrase}, ${fixPhrase}${coachPhrase}.`),
     };
   } catch {
     guarantee = null;
@@ -1025,7 +1029,7 @@ function formatImproveReport(result = {}) {
 // those trailer lines. commits with no trailer still count as human, so the
 // metric overcounts revisions; accepted on purpose.
 //
-// if a human commit touches any of the same files within 72 hours, that
+// if a human commit changes lines the landing wrote within 72 hours, that
 // landing failed the guarantee.
 //
 // renames are NOT followed: `git log --follow` is per-file and would cost one
@@ -1038,8 +1042,13 @@ const REVISION_WINDOW_HOURS = 72;
 // matter of routine (daily logs, now.md, run receipts), so overlap there says
 // nothing about the quality of a landing. On 2026-08-21 half the "revisions"
 // in a live reading were journal commits following journal commits. Only
-// product-file overlap counts.
+// product-file overlap counts. The same holds for shared index files: on
+// 2026-10-15 one human commit read as 14 of 17 revisions because it moved a
+// few map-note lines that nearly every landing also adds to.
 const REVISION_IGNORED_FILES = [
+  /^atris\/MAP\.md$/,
+  /^atris\/refs\/MAP-NOTES\.md$/,
+  /^test\/fast-tests\.txt$/,
   /^atris\/logs\//,
   /^atris\/runs\//,
   /^atris\/team\/[^/]+\/(?:logs|now\.md)/,
@@ -1052,6 +1061,23 @@ const REVISION_IGNORED_FILES = [
 function isRevisionSignalFile(file) {
   return !REVISION_IGNORED_FILES.some((re) => re.test(String(file || '')));
 }
+
+// A person editing a member's role, goals, context, or the team roster after a
+// landing is coaching the team, not fixing broken work. Live 2026-10-15: most
+// of 51 "revisions" in atris-desktop-v2 were goals.json and MEMBER.md edits,
+// so the boot line told the operator they fixed work they had only steered.
+const COACHING_FILES = [
+  /^atris\/team\/[^/]+\/(?:MEMBER\.md|MISSION\.md|WAKE\.md|lessons\.md|goals\.(?:json|md))$/,
+  /^atris\/team\/[^/]+\/(?:context|skills)\//,
+  /^atris\/team\/ROSTER\.(?:json|md)$/,
+  /^atris\/ROSTER\.md$/,
+  /^atris\/(?:PERSONA|STANDARD)\.md$/,
+  /^atris\/policies\//,
+];
+
+function isCoachingFile(file) {
+  return COACHING_FILES.some((re) => re.test(String(file || '')));
+}
 const REVISION_WINDOW_MS = REVISION_WINDOW_HOURS * 60 * 60 * 1000;
 const AGENT_TRAILER_MARKERS = [
   'atris-builder[bot]',
@@ -1213,7 +1239,7 @@ function loadRevisionFilesCache(root) {
 
 function saveRevisionFilesCache(cache) {
   if (!cache.writable || !cache.dirty) return;
-  const entries = { ...cache.used };
+  const entries = Object.fromEntries(Object.entries(cache.used).filter(([, files]) => Array.isArray(files)));
   let count = Object.keys(entries).length;
   for (const [hash, files] of Object.entries(cache.entries)) {
     if (count >= REVISION_FILES_CACHE_MAX) break;
@@ -1224,9 +1250,61 @@ function saveRevisionFilesCache(cache) {
   ignoredCache.writeCacheJson(cache.root, REVISION_FILES_CACHE, { version: 1, shallow: cache.shallow, entries });
 }
 
+/**
+ * Which mainline commit brought each commit onto the line HEAD follows: a
+ * mainline commit brings itself, a branch commit arrives with the oldest
+ * merge that reaches it. Built from the history already read, so no extra git
+ * calls. Commits outside the window stay unknown.
+ */
+function mainlineArrivals(commits) {
+  const byHash = new Map(commits.map((commit) => [commit.hash, commit]));
+  const mainline = [];
+  for (let c = commits[0]; c && !mainline.includes(c); c = byHash.get(c.parents[0])) mainline.push(c);
+  const arrival = new Map(mainline.map((m) => [m.hash, m.hash]));
+  for (const m of mainline.slice().reverse()) {
+    const stack = m.parents.slice(1);
+    while (stack.length) {
+      const hash = stack.pop();
+      if (arrival.has(hash) || !byHash.has(hash)) continue;
+      arrival.set(hash, m.hash);
+      stack.push(...byHash.get(hash).parents);
+    }
+  }
+  return arrival;
+}
+
+/**
+ * Commits that wrote the lines a plain commit changed in one file, read with
+ * blame on its parent. A pure insertion counts the line it went in under, so
+ * adding a missing line to someone's block still touches that block. null
+ * when git cannot say (binary, new file, blame error); the caller then falls
+ * back to same-file overlap.
+ */
+function linesAuthoredBefore(cwdRoot, commit, file) {
+  const parent = commit.parents[0];
+  if (!parent) return null;
+  try {
+    const diff = gitLines(cwdRoot, [...NAME_ARGS, 'diff', '-U0', '--no-color', '--no-ext-diff', '--no-textconv', '--no-renames', parent, commit.hash, '--', file]);
+    const ranges = [];
+    for (const m of diff.matchAll(/^@@ -(\d+)(?:,(\d+))? /gm)) {
+      const start = Number(m[1]);
+      const count = m[2] === undefined ? 1 : Number(m[2]);
+      if (count > 0) ranges.push('-L', `${start},${start + count - 1}`);
+      else ranges.push('-L', `${Math.max(start, 1)},${Math.max(start, 1)}`);
+    }
+    if (!ranges.length) return null;
+    const blame = gitLines(cwdRoot, [...NAME_ARGS, 'blame', '--porcelain', ...ranges, parent, '--', file]);
+    const authors = new Set();
+    for (const m of blame.matchAll(/^([0-9a-f]{40,64}) \d+ \d+/gm)) authors.add(m[1]);
+    return [...authors];
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Read the last N days of history and pair every agent landing with the
- * human commits that touched the same files within the 72-hour window.
+ * human commits that changed its lines within the 72-hour window.
  */
 function collectRevisionSignals(root, options = {}) {
   const days = Number.isFinite(options.days) && options.days > 0 ? Math.round(options.days) : DEFAULT_REVISIONS_DAYS;
@@ -1288,25 +1366,48 @@ function collectRevisionSignals(root, options = {}) {
     }
     return cache.used[commit.hash];
   };
+  // Saved beside the file lists under a key no commit hash can take.
+  const authorsOf = (commit, file) => {
+    const key = `lines:${commit.hash}:${file}`;
+    if (!(key in cache.used)) {
+      const hit = cache.entries[key];
+      cache.used[key] = Array.isArray(hit) ? hit : linesAuthoredBefore(root, commit, file);
+      if (!Array.isArray(hit) && cache.used[key]) cache.dirty = true;
+    }
+    return cache.used[key];
+  };
 
+  // A commit that reached the mainline in the same merge as the landing came
+  // in with it, before anything had landed for a person to fix.
+  const arrival = mainlineArrivals(commits);
   const revisions = [];
   for (const landing of landings) {
     const landedFiles = new Set(filesOf(landing).filter(isRevisionSignalFile));
     if (!landedFiles.size) continue;
+    const landedWith = arrival.get(landing.hash);
     const revisedBy = [];
     const touched = new Set();
     for (const human of humans) {
       if (human.ms <= landing.ms || human.ms > landing.ms + REVISION_WINDOW_MS) continue;
-      const overlap = filesOf(human).filter((f) => landedFiles.has(f));
+      if (landedWith && arrival.get(human.hash) === landedWith) continue;
+      // Same file is not enough: the commit has to change lines that came in
+      // with the landing. Live 2026-10-15: a follow-up to one change read as
+      // a fix of four older landings that only shared its files.
+      const overlap = filesOf(human).filter((f) => landedFiles.has(f)).filter((f) => {
+        const authors = authorsOf(human, f);
+        return !authors || authors.some((h) => h === landing.hash || (landedWith && arrival.get(h) === landedWith));
+      });
       if (!overlap.length) continue;
       revisedBy.push({ hash: human.hash, subject: human.subject, at: human.at });
       overlap.forEach((f) => touched.add(f));
     }
     if (revisedBy.length) {
+      const files = [...touched].sort();
       revisions.push({
         landing: { hash: landing.hash, subject: landing.subject, at: landing.at },
         revised_by: revisedBy,
-        files: [...touched].sort(),
+        files,
+        kind: files.every(isCoachingFile) ? 'coaching' : 'fix',
       });
     }
   }
@@ -1320,6 +1421,9 @@ function collectRevisionSignals(root, options = {}) {
     landings: landings.length,
     revised: revisions.length,
     rate: landings.length ? revisions.length / landings.length : 0,
+    fixed: revisions.filter((r) => r.kind === 'fix').length,
+    coached: revisions.filter((r) => r.kind === 'coaching').length,
+    fix_rate: landings.length ? revisions.filter((r) => r.kind === 'fix').length / landings.length : 0,
     revisions,
   };
 }
@@ -1339,9 +1443,15 @@ function formatRevisionsReport(summary = {}) {
   lines.push(`agent landings in the last ${plural(days, 'day')}: ${summary.landings}.`);
   lines.push(`landings a human then revised: ${summary.revised}.`);
   lines.push(`revision rate: ${Math.round((summary.rate || 0) * 100)} percent. the target is zero.`);
+  if (Number.isFinite(summary.fixed)) {
+    lines.push(`real fixes: ${summary.fixed}. coaching (roles, goals, context): ${summary.coached || 0}.`);
+  }
   for (const item of Array.isArray(summary.revisions) ? summary.revisions : []) {
     lines.push('');
-    lines.push(`an agent landed "${plainSentence(item.landing.subject)}". a human then changed ${listFilesPhrase(item.files)} within ${REVISION_WINDOW_HOURS} hours.`);
+    const after = item.kind === 'coaching'
+      ? `a human then coached the team in ${listFilesPhrase(item.files)} within ${REVISION_WINDOW_HOURS} hours.`
+      : `a human then changed ${listFilesPhrase(item.files)} within ${REVISION_WINDOW_HOURS} hours.`;
+    lines.push(`an agent landed "${plainSentence(item.landing.subject)}". ${after}`);
   }
   return lines.join('\n');
 }