atris 3.70.0 → 3.71.0

package/commands/team.js

@@ -175,6 +175,19 @@ function memberIsActive({ awake, activity }) {
 
 const ACTIVITY_WINDOW_MS = IDLE_AFTER_DAYS * 24 * 60 * 60 * 1000;
 
+// A log whose only entry is the note setup writes ("Member initialized") is
+// not work: a fresh project's members have never run.
+const SEED_LOG_MAX_BYTES = 1024;
+function isSeedOnlyLog(file) {
+  try {
+    if (fs.statSync(file).size > SEED_LOG_MAX_BYTES) return false;
+    const headings = fs.readFileSync(file, 'utf8').split(/\r?\n/).filter((line) => line.startsWith('## '));
+    return headings.length > 0 && headings.every((line) => /·\s*Member initialized\s*$/.test(line));
+  } catch {
+    return false;
+  }
+}
+
 // Dated file names under the member's logs/ folder and one level below it
 // (logs/2026/2026-09-28.md). The date in the name, never the file time: a
 // fresh checkout stamps every file with today.
@@ -191,12 +204,12 @@ function memberLogDays(member, root) {
       try { inner = fs.readdirSync(path.join(dir, entry.name)); } catch { inner = []; }
       for (const name of inner) {
         const day = logFileDay(name);
-        if (day) days.push(day);
+        if (day && !isSeedOnlyLog(path.join(dir, entry.name, name))) days.push(day);
       }
       continue;
     }
     const day = logFileDay(entry.name);
-    if (day) days.push(day);
+    if (day && !isSeedOnlyLog(path.join(dir, entry.name))) days.push(day);
   }
   return days;
 }
@@ -432,6 +445,63 @@ function liveRunJson(run) {
   };
 }
 
+function realFolder(folder) {
+  try { return fs.realpathSync(folder); } catch { return path.resolve(folder); }
+}
+
+// Each run's working folder in one lookup: /proc on Linux, lsof elsewhere.
+// A folder that cannot be read stays unknown.
+function liveRunFolders(pids, deps = {}) {
+  if (typeof deps.runFolders === 'function') return deps.runFolders(pids);
+  const folders = new Map();
+  if (!pids.length) return folders;
+  if (process.platform === 'linux') {
+    for (const pid of pids) {
+      try { folders.set(pid, fs.readlinkSync(`/proc/${pid}/cwd`)); } catch { /* unknown */ }
+    }
+    return folders;
+  }
+  let result;
+  try {
+    result = spawnSync('lsof', ['-a', '-p', pids.join(','), '-d', 'cwd', '-Fpn'], { encoding: 'utf8', timeout: 3000 });
+  } catch {
+    return folders;
+  }
+  let pid = null;
+  for (const line of String(result?.stdout || '').split(/\r?\n/)) {
+    if (line.startsWith('p')) pid = Number(line.slice(1));
+    else if (line.startsWith('n') && pid) folders.set(pid, line.slice(1));
+  }
+  return folders;
+}
+
+// This project's folders: the checkout and every work copy git knows for it.
+function projectFolders(root, deps = {}) {
+  if (Array.isArray(deps.projectFolders)) return deps.projectFolders.map(realFolder);
+  const folders = [realFolder(root)];
+  const result = spawnSync('git', ['worktree', 'list', '--porcelain'], { cwd: root, encoding: 'utf8', timeout: 3000 });
+  if (result && result.status === 0) {
+    for (const line of String(result.stdout || '').split(/\r?\n/)) {
+      if (line.startsWith('worktree ')) folders.push(realFolder(line.slice('worktree '.length)));
+    }
+  }
+  return [...new Set(folders)];
+}
+
+// Live runs on this machine that work in this project. A run in another
+// project is not this team working; a run whose folder cannot be read stays.
+function liveRunsInProject(runs, root, deps = {}) {
+  if (!runs.length) return runs;
+  const folders = projectFolders(root, deps);
+  const where = liveRunFolders(runs.map((run) => run.pid), deps);
+  return runs.filter((run) => {
+    const folder = where.get(run.pid);
+    if (!folder) return true;
+    const real = realFolder(folder);
+    return folders.some((base) => real === base || real.startsWith(base + path.sep));
+  });
+}
+
 // The table's rows, in order, for text and json alike. Parked members are
 // left out unless `all` (or unless they are working right now).
 function teamTableRows(rosterRows, { lineup = null, liveRuns = [], all = false } = {}) {
@@ -537,6 +607,139 @@ function teamJsonRows(allRows, deps = {}) {
   return [...members, ...others];
 }
 
+// The first paragraph under the title of a MEMBER.md, for files written
+// without a header block. A leading "role:" label is dropped.
+function memberFileOpening(member) {
+  let text = '';
+  try { text = fs.readFileSync(member.path, 'utf8'); } catch { return ''; }
+  const body = text.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');
+  const paragraph = [];
+  for (const line of body.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('#') || !trimmed) {
+      if (paragraph.length) break;
+      continue;
+    }
+    paragraph.push(trimmed);
+  }
+  return paragraph.join(' ').replace(/^role:\s*/i, '');
+}
+
+const MEMBER_DOES_MAX = 140;
+
+// What a member does, in its own words: the description, else the role,
+// else the opening of its file. Only the first sentence, so the column
+// stays one idea per member.
+function memberDoes(member) {
+  const role = String(member?.role || '').trim();
+  const candidates = [member?.description, role === '(no role)' ? '' : role, memberFileOpening(member)];
+  const name = String(member?.name || '').trim().toLowerCase();
+  for (const candidate of candidates) {
+    const sentence = String(candidate || '').trim().split(/(?<=\.)\s/)[0]
+      .replace(/[\u2013\u2014]/g, '-')
+      .replace(/\s+/g, ' ')
+      .toLowerCase()
+      .replace(/[.\s]+$/, '');
+    const text = name && sentence.startsWith(name) ? sentence.slice(name.length).replace(/^[\s:,-]+/, '') : sentence;
+    if (!text) continue;
+    if (text.length <= MEMBER_DOES_MAX) return text;
+    const cut = text.slice(0, MEMBER_DOES_MAX);
+    return `${cut.slice(0, cut.lastIndexOf(' ')).replace(/[\s,;:-]+$/, '')}…`;
+  }
+  return 'no role written yet';
+}
+
+// `atris member roster`: one line per member with the full name, working or
+// idle, the engine it really runs on, and what it does. Same facts as the
+// team table: a live run in this project means working, the lineup names
+// the engine. Parked members leave the list unless `all`.
+function memberRosterRows(members, { lineup = null, liveRuns = [], parked = new Set(), all = false } = {}) {
+  const runsByMember = new Map();
+  for (const run of Array.isArray(liveRuns) ? liveRuns : []) {
+    const key = String(run.member || '').trim().toLowerCase();
+    if (key && !runsByMember.has(key)) runsByMember.set(key, run);
+  }
+  const rows = members.map((member) => {
+    const key = String(member.name || '').trim().toLowerCase();
+    const run = runsByMember.get(key);
+    const place = memberLineup(lineup, key);
+    const isParked = parked.has(member.name) || isParkedFrontmatter(member.frontmatter);
+    return {
+      name: member.name,
+      state: run ? 'working' : isParked ? 'parked' : 'idle',
+      engine: run ? liveRunEngineText(run) : place && place.engine ? placedEngineText(place) : 'not set',
+      does: memberDoes(member),
+      parked: isParked,
+    };
+  });
+  const order = { working: 0, idle: 1, parked: 2 };
+  return rows
+    .filter((row) => all || !row.parked || row.state === 'working')
+    .sort((a, b) => order[a.state] - order[b.state] || a.name.localeCompare(b.name));
+}
+
+const MEMBER_ROSTER_COLUMNS = Object.freeze([
+  { header: 'MEMBER' },
+  { header: 'STATUS' },
+  { header: 'ENGINE' },
+  { header: 'WHAT IT DOES', wrap: true, min: 20 },
+]);
+
+function renderMemberRoster(members, deps = {}) {
+  if (!members.length) return 'no team members yet. create one with: atris member create <name> --role="..."';
+  const width = terminalWidth(deps.termWidth);
+  const rows = memberRosterRows(members, deps);
+  const lines = [renderTable(MEMBER_ROSTER_COLUMNS, rows.map((row) => [row.name, row.state, row.engine, row.does]), { width })];
+  const working = rows.filter((row) => row.state === 'working').length;
+  lines.push('', `${rows.length} ${rows.length === 1 ? 'member' : 'members'}, ${working} working now.`);
+  const shown = new Set(rows.map((row) => row.name));
+  const hidden = members.filter((member) => !shown.has(member.name)).map((member) => member.name);
+  if (hidden.length) {
+    const names = [...hidden];
+    names[0] = `parked (${hidden.length}): ${names[0]}`;
+    names[names.length - 1] = `${names[names.length - 1]} · atris member roster --all to show them`;
+    lines.push(wrapCommaNames(names, width));
+  }
+  return lines.join('\n');
+}
+
+function memberRosterCommand(args = [], deps = {}) {
+  const root = deps.root || process.cwd();
+  const members = (deps.members || collectMembers(root, deps)).filter((member) => !isTemplateMember(member));
+  const parked = new Set(members.filter((member) => isMemberParked(root, member.name)).map((member) => member.name));
+  const lineup = deps.lineup !== undefined ? deps.lineup : readLineupSafe(root, deps.lineupNow || new Date());
+  const liveRuns = Array.isArray(deps.liveRuns) ? deps.liveRuns : liveRunsInProject(listLiveEngineRuns(deps), root, deps);
+  const view = { lineup: lineup && lineup.ok ? lineup : null, liveRuns, parked, all: args.includes('--all') };
+  const write = deps.write || ((text) => process.stdout.write(text));
+  if (args.includes('--json')) {
+    const byName = new Map(memberRosterRows(members, { ...view, all: true }).map((row) => [row.name, row]));
+    write(`${JSON.stringify({
+      ok: true,
+      count: members.length,
+      members: members.map((member) => {
+        const row = byName.get(member.name);
+        return {
+          name: member.name,
+          ...(row.parked ? { parked: true } : {}),
+          state: row.state,
+          engine: row.engine,
+          does: row.does,
+          role: member.role,
+          format: member.format,
+          skills: member.format === 'directory' ? member.skillCount : null,
+          context: member.format === 'directory' ? member.contextCount : null,
+          version: member.version || null,
+        };
+      }),
+    }, null, 2)}\n`);
+    return 0;
+  }
+  const output = renderMemberRoster(members, { ...view, termWidth: deps.termWidth });
+  if (deps.lineup === undefined && lineup && !lineup.ok) write(`${output}\n\n${LINEUP_UNREADABLE}\n`);
+  else write(`${output}\n`);
+  return 0;
+}
+
 function renderTeamRosterHtml(allRows, meta = {}) {
   const rosterRows = withParkedLabels(allRows, Boolean(meta.all)).rows;
   const activeRows = rosterRows.filter((entry) => entry.active);
@@ -907,8 +1110,10 @@ function teamCommand(args = [], deps = {}) {
     const lineup = deps.lineup !== undefined
       ? deps.lineup
       : readLineupSafe(deps.root || repoRoot(deps.cwd || process.cwd()), deps.lineupNow || new Date());
-    // Who is working this minute: live engine runs on this machine.
-    const liveRuns = Array.isArray(deps.liveRuns) ? deps.liveRuns : listLiveEngineRuns(deps);
+    // Who is working this minute: live engine runs in this project.
+    const liveRuns = Array.isArray(deps.liveRuns)
+      ? deps.liveRuns
+      : liveRunsInProject(listLiveEngineRuns(deps), deps.root || repoRoot(deps.cwd || process.cwd()), deps);
     const output = json
       ? JSON.stringify(teamJsonRows(roster, { lineup, liveRuns }), null, 2)
       : renderTeamRoster(roster, { ...deps, lineup, liveRuns, all });
@@ -933,6 +1138,9 @@ module.exports = {
   collectTeamPrune,
   recordMemberActivity,
   collectTeamRoster,
+  memberRosterCommand,
+  memberRosterRows,
+  renderMemberRoster,
   renderTeamPrune,
   renderTeamRoster,
   teamCommand,

package/commands/unknowns.js

@@ -261,6 +261,9 @@ function runRunnerPrompt(root, prompt) {
     const cmd = buildRunnerCommand({ promptFile });
     const env = { ...process.env };
     delete env.CLAUDECODE;
+    // 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(root, { engine: 'runner', task: 'unknowns' });
     const result = spawnSync(cmd, [], {
       cwd: root,
       encoding: 'utf8',
@@ -270,7 +273,17 @@ function runRunnerPrompt(root, prompt) {
       maxBuffer: 10 * 1024 * 1024,
       env,
     });
-    if (result.error) return { ok: false, reason: result.error.message || 'runner failed' };
+    // spawnSync does not throw, so a failure is passed in the thrown shape.
+    const failed = result.error || result.signal || result.status !== 0;
+    const end = endResource(failed ? {
+      code: result.error && result.error.code,
+      signal: result.signal,
+      stderr: result.stderr,
+      message: result.error ? result.error.message : `runner exited ${result.status}`,
+    } : null);
+    const cause = end && end.cause ? `; ${end.cause}` : '';
+    if (result.error) return { ok: false, reason: `${result.error.message || 'runner failed'}${cause}` };
+    if (result.signal) return { ok: false, reason: `runner stopped by ${result.signal}${cause}` };
     if (result.status !== 0) {
       return { ok: false, reason: clipLine(result.stderr || result.stdout || `runner exited ${result.status}`, 300) };
     }
@@ -618,5 +631,6 @@ module.exports = {
   unknownsCommand,
   showHelp,
   fallbackPayload,
+  runRunnerPrompt,
   gatherTerritoryContext,
 };

package/commands/verify.js

@@ -581,6 +581,45 @@ function checkMapForFiles(atrisDir, changes) {
   return { documented: documented >= fileChanges.length / 2 };
 }
 
+const NPM_MUTATING_SUBCOMMANDS = new Set([
+  'i', 'install', 'add',
+  'un', 'uninstall', 'rm', 'r', 'remove', 'unlink',
+  'up', 'update', 'upgrade',
+]);
+const NPM_GLOBAL_FLAG_RE = /^(?:-g|--global(?:=true)?|--location=global)$/;
+const NPM_GLOBAL_ENV_RE = /\bnpm_config_(?:global=(?:true|1)\b|location=global\b)/i;
+
+/**
+ * Return the first line of a rubric script that installs, removes, or links
+ * a package globally, or null. A rubric once ran `npm i -g atris@<old>` and
+ * swapped the CLI under every agent on the machine; proofs stay read-only.
+ */
+function findGlobalInstall(script) {
+  const text = String(script || '').replace(/\\\n/g, ' ');
+  // An exported or inline npm_config_global turns any later install global.
+  const globalEnv = NPM_GLOBAL_ENV_RE.test(text.replace(/(^|\s)#.*$/gm, ''));
+  for (const rawLine of text.split('\n')) {
+    const line = rawLine.replace(/(^|\s)#.*$/, '').trim();
+    if (!line) continue;
+    for (const segment of line.split(/&&|\|\||[;|&]/)) {
+      const tokens = segment.trim().split(/\s+/).filter(Boolean);
+      while (tokens.length && (tokens[0] === 'sudo' || /^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0]))) tokens.shift();
+      const tool = tokens[0];
+      if (tool === 'yarn' && tokens[1] === 'global' && tokens[2] !== 'list' && tokens[2] !== 'bin' && tokens[2] !== 'dir') {
+        return rawLine.trim();
+      }
+      if (tool !== 'npm' && tool !== 'pnpm') continue;
+      const args = tokens.slice(1);
+      const sub = args.find((token, i) => !token.startsWith('-') && args[i - 1] !== '--location');
+      if (sub === 'link' || sub === 'ln') return rawLine.trim();
+      const isGlobal = globalEnv || args.some((token, i) =>
+        NPM_GLOBAL_FLAG_RE.test(token) || (token === '--location' && args[i + 1] === 'global'));
+      if (isGlobal && NPM_MUTATING_SUBCOMMANDS.has(sub)) return rawLine.trim();
+    }
+  }
+  return null;
+}
+
 /**
  * atris verify <slug> --section <name>
  *
@@ -617,6 +656,13 @@ function verifyRubric(slug, section, opts = {}) {
     return 2;
   }
   const script = match[1];
+  const globalInstall = findGlobalInstall(script);
+  if (globalInstall) {
+    console.error(`✗ Refusing to run "## ${section}": it changes globally installed packages.`);
+    console.error(`  ${globalInstall}`);
+    console.error('  Proofs must be read-only. Move install steps to prose or a non-bash fence.');
+    return 2;
+  }
   const os = require('os');
   const tmpFile = path.join(os.tmpdir(), `atris-verify-${Date.now()}-${Math.floor(Math.random() * 1e6)}.sh`);
   fs.writeFileSync(tmpFile, `#!/usr/bin/env bash\nset -e\n${script}\n`);

package/commands/worktree.js

@@ -5,12 +5,16 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 const { hasFlag, readFlag } = require('../lib/arg-parser');
 const { stampLatestOpenBriefForWorktree } = require('../lib/brief-ledger');
-const { isConductorArtifact } = require('../lib/conductor-artifacts');
+const { isConductorArtifact, isConductorUntracked } = require('../lib/conductor-artifacts');
 const { fixMapDocs } = require('../lib/map-refs');
 const { sleepSync } = require('../lib/sleep-sync');
 const close = require('./close');
 
-const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+// Files atris regenerates on its own. Unstaged churn in them is restored
+// before ship commits, unless the commit message names the file. The task
+// projection is rewritten by any task command run in a work folder, and two
+// parallel landings that each carry a copy always clash.
+const REGEN_ADAPTER_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md', '.atris/state/tasks.projection.json'];
 const COMMAND_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 const GIT_OID_PATTERN = /^[0-9a-f]{40,64}$/;
 const ONE_LAP_PROOF_REF_PATTERN = /^refs\/atris\/one-lap\/([0-9a-f]{40,64})$/;
@@ -179,6 +183,14 @@ function lastRunBranch(root, owner, task, base, skip) {
   return cherry.stdout.split('\n').some((line) => line.startsWith('+')) ? newest : null;
 }
 
+// True only when git proves the branch no longer merges cleanly with the base.
+// merge-tree --write-tree exits 1 on conflict; an error or old git keeps the
+// resume as before.
+function conflictsWithBase(root, base, branch) {
+  const result = runGit(['merge-tree', '--write-tree', '--name-only', base, branch], { cwd: root, check: false });
+  return result.status === 1;
+}
+
 function defaultWorktreePath(root, member, task, now = new Date()) {
   const name = `${slugify(member, 'member', 24)}-${slugify(task, 'task', 36)}-${stamp(now)}`;
   return path.join(path.dirname(root), '.agent-worktrees', path.basename(root), name);
@@ -466,10 +478,30 @@ function statusCounts(root, {
 
 // Remove conductor plumbing from the index after a broad `git add -A`, so the commit
 // records engine output only. Paths that were never staged are simply not listed.
+// GitHub refuses a merge with "Base branch was modified" when another PR
+// merged into the same base a moment earlier; the same merge succeeds on a
+// second try. On 2026-10-15 five parallel dispatches lost three landings to
+// it. Retry only that message, a few times, with a short wait.
+const BASE_MODIFIED_PATTERN = /Base branch was modified/i;
+function mergePrWithRetry(mergeArgs, root, { run = spawnSync, wait = sleepSync, attempts = 4 } = {}) {
+  let merged = run('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
+  for (let attempt = 1; attempt < attempts && merged.status !== 0
+    && BASE_MODIFIED_PATTERN.test(`${merged.stderr || ''}${merged.stdout || ''}`); attempt += 1) {
+    console.log(`merge: base branch moved, retrying (${attempt + 1}/${attempts})`);
+    wait(1500 * attempt);
+    merged = run('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
+  }
+  return merged;
+}
+
 function unstageConductorArtifacts(root) {
   const staged = runGit(['diff', '--cached', '--name-only'], { cwd: root, check: false });
   if (staged.status !== 0) return [];
-  const drop = String(staged.stdout || '').split(/\r?\n/).filter(Boolean).filter(isConductorArtifact);
+  const added = runGit(['diff', '--cached', '--name-only', '--diff-filter=A'], { cwd: root, check: false });
+  const newFiles = new Set(String(added.stdout || '').split(/\r?\n/).filter(Boolean));
+  // A file this commit would add under .atris/ is the tool's own state, never work.
+  const drop = String(staged.stdout || '').split(/\r?\n/).filter(Boolean)
+    .filter((file) => isConductorArtifact(file) || (newFiles.has(file) && isConductorUntracked(file)));
   if (drop.length) runGit(['reset', '-q', 'HEAD', '--', ...drop], { cwd: root, check: false });
   return drop;
 }
@@ -572,9 +604,18 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
   const staleBase = refreshRemoteRef(root, checkoutBase);
   // A retry of the same job starts from the last run's unlanded commits; it
   // still ships to the mainline.
-  const resumedFrom = (!pathOverride && !branchOverride)
+  let resumedFrom = (!pathOverride && !branchOverride)
     ? lastRunBranch(root, owner, task, checkoutBase, branch)
     : null;
+  // A last run that now conflicts with the mainline would hand its conflict
+  // to the retry, which then cannot land on the first try. Start fresh; the
+  // old branch keeps its commits.
+  let skippedResume = null;
+  if (resumedFrom && conflictsWithBase(root, checkoutBase, resumedFrom)) {
+    skippedResume = resumedFrom;
+    resumedFrom = null;
+    console.error(`note: the last run's branch ${skippedResume} no longer merges cleanly with ${checkoutBase}, so this run starts fresh; that branch keeps its commits`);
+  }
   const startPoint = resumedFrom || checkoutBase;
   const ref = `refs/heads/${branch}`;
   const existed = runGit(['show-ref', '--verify', '--quiet', ref], { cwd: root, check: false }).status !== 1;
@@ -590,7 +631,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     if (registered) {
       if (!fs.existsSync(target) || fs.realpathSync(registered.path) !== fs.realpathSync(target)
         || registered.head !== startCommit) return;
-      const dirt = statusCounts(target, { ignoreUntracked: isConductorArtifact });
+      const dirt = statusCounts(target, { ignoreUntracked: isConductorUntracked });
       if (!dirt || dirt.staged || dirt.unstaged || dirt.untracked) return;
       // No engine has started. Normal removal still refuses unexpected dirt.
       runGit(['worktree', 'remove', target], { cwd: root });
@@ -608,6 +649,15 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     }
     sleepSync(100 * (attempt + 1));
   }
+  // A resumed branch takes in what the mainline gained since, or a job that
+  // keeps resuming drifts further behind every run until it clashes
+  // (2026-10-15: five long jobs sat 103 to 129 commits behind). The clash
+  // check above proved this merge is clean; if git still refuses, the run
+  // keeps the old start instead of failing.
+  if (resumedFrom) {
+    const caughtUp = runGit(['merge', '--no-edit', '-m', `Merge ${checkoutBase} into ${branch}`, checkoutBase], { cwd: target, check: false });
+    if (caughtUp.status !== 0) runGit(['merge', '--abort'], { cwd: target, check: false });
+  }
   try {
     runGit(['config', `branch.${branch}.atris-base`, shipBase], { cwd: target });
     runGit(['config', `branch.${branch}.atris-owner`, owner], { cwd: target });
@@ -624,6 +674,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
         base: shipBase,
         checkout_base: checkoutBase,
         resumed_from: resumedFrom,
+        skipped_resume: skippedResume,
         workspace_root: root,
         created_at: now.toISOString(),
       }, null, 2) + '\n',
@@ -633,7 +684,7 @@ function createAgentWorktree({ root = repoRoot(), member = '', agent = '', task,
     discardFailedStart();
     throw error;
   }
-  return { path: target, branch, base: shipBase, checkoutBase, resumedFrom, owner, reapedBeforeStart, cachePrunedBeforeStart };
+  return { path: target, branch, base: shipBase, checkoutBase, resumedFrom, skippedResume, owner, reapedBeforeStart, cachePrunedBeforeStart };
 }
 
 function startWorktree(args) {
@@ -949,7 +1000,7 @@ function shipWorktree(args) {
   const ignoredUnstagedFiles = dryRun ? new Set(skippedAdapters) : new Set();
   // Conductor plumbing must not make the checkout look dirty, or a flight where the
   // engine wrote nothing commits the fleet's own prompt file and calls it work.
-  const counts = statusCounts(root, { ignoredUnstagedFiles, ignoreUntracked: isConductorArtifact })
+  const counts = statusCounts(root, { ignoredUnstagedFiles, ignoreUntracked: isConductorUntracked })
     || { staged: 0, unstaged: 0, untracked: 0 };
   const dirty = counts.staged || counts.unstaged || counts.untracked;
   if (dirty && !message) {
@@ -989,7 +1040,7 @@ function shipWorktree(args) {
     // already present before the verifier ran, so counting it here blocks a clean ship.
     const afterVerify = dryRun
       ? { staged: 0, unstaged: 0, untracked: 0 }
-      : statusCounts(root, { ignoreUntracked: isConductorArtifact })
+      : statusCounts(root, { ignoreUntracked: isConductorUntracked })
         || { staged: 0, unstaged: 0, untracked: 0 };
     if (!dryRun && (afterVerify.staged || afterVerify.unstaged || afterVerify.untracked)) {
       console.error(
@@ -1029,7 +1080,7 @@ function shipWorktree(args) {
             throw new Error((switched.stderr || switched.stdout || `git switch ${targetBranch} failed`).trim());
           }
         }
-        const primaryCounts = statusCounts(primary, { ignoreUntracked: isConductorArtifact }) || { staged: 0, unstaged: 0, untracked: 0 };
+        const primaryCounts = statusCounts(primary, { ignoreUntracked: isConductorUntracked }) || { staged: 0, unstaged: 0, untracked: 0 };
         if (primaryCounts.staged || primaryCounts.unstaged || primaryCounts.untracked) {
           throw new Error(
             `primary checkout dirty staged=${primaryCounts.staged} ` +
@@ -1060,7 +1111,7 @@ function shipWorktree(args) {
         const mergeArgs = ['pr', 'merge'];
         if (mergeRef) mergeArgs.push(mergeRef);
         mergeArgs.push('--merge');
-        const merged = spawnSync('gh', mergeArgs, { cwd: root, encoding: 'utf8' });
+        const merged = mergePrWithRetry(mergeArgs, root);
         if (merged.status !== 0) throw new Error((merged.stderr || merged.stdout || 'gh pr merge failed').trim());
         // `gh pr merge` on an already-merged PR exits 0 with a warning
         // instead of failing, which would otherwise report a false landing.
@@ -1104,7 +1155,7 @@ function guard(args) {
   // Conductor plumbing (worktree metadata, the fleet prompt written for this very
   // engine, runtime scratch, the brief ledger) must not count as dirt, otherwise the
   // harness blocks the engine with the harness's own files.
-  const counts = statusCounts(root, { ignoreUntracked: isConductorArtifact });
+  const counts = statusCounts(root, { ignoreUntracked: isConductorUntracked });
   if (counts && (counts.staged || counts.unstaged || counts.untracked) && !hasFlag(args, '--allow-dirty')) {
     console.error(`blocked: checkout is dirty staged=${counts.staged} unstaged=${counts.unstaged} untracked=${counts.untracked}`);
     return 3;
@@ -1162,12 +1213,14 @@ function canonicalPath(value) {
   }
 }
 
+// null means the scan failed: we cannot tell who is inside, so callers keep
+// every folder. An empty list would read as "nobody is here" and delete.
 function listActiveProcessCwds() {
   const result = spawnSync('lsof', ['-n', '-a', '-d', 'cwd', '-F', 'n'], {
     encoding: 'utf8',
     maxBuffer: COMMAND_MAX_BUFFER_BYTES,
   });
-  if (result.status !== 0) return [];
+  if (result.error || result.status !== 0) return null;
   return String(result.stdout || '')
     .split(/\r?\n/)
     .filter((line) => line.startsWith('n'))
@@ -1175,7 +1228,45 @@ function listActiveProcessCwds() {
     .filter(Boolean);
 }
 
+// Absolute paths named on each program's command line, including flag values
+// like --require=/x.js. A program can run a script from a work folder while
+// its current folder is elsewhere; the folder scan alone misses it. The list
+// prints arguments unquoted, so a path with a space is also kept as the rest
+// of the line from where it starts; the folder match is a prefix check.
+function parseProcessArgPaths(psOutput) {
+  const paths = new Set();
+  const starts = /(?:^|\s)(?:[^\s=]*=)?(?=\/)/g;
+  for (const raw of String(psOutput || '').split(/\r?\n/)) {
+    const line = raw.trim();
+    for (const match of line.matchAll(starts)) {
+      const rest = line.slice(match.index + match[0].length);
+      const token = rest.split(/\s/, 1)[0];
+      if (token.length > 1) paths.add(token);
+      if (rest.length > token.length) paths.add(rest);
+    }
+  }
+  return [...paths];
+}
+
+function listActiveProcessArgPaths() {
+  const result = spawnSync('ps', ['-axww', '-o', 'args='], {
+    encoding: 'utf8',
+    maxBuffer: COMMAND_MAX_BUFFER_BYTES,
+  });
+  if (result.error || result.status !== 0) return [];
+  return parseProcessArgPaths(result.stdout);
+}
+
+// Everything a running program is anchored to: its current folder plus any
+// script path on its command line.
+function listActiveProcessPaths() {
+  const cwds = listActiveProcessCwds();
+  if (!Array.isArray(cwds)) return cwds;
+  return cwds.concat(listActiveProcessArgPaths());
+}
+
 function worktreeHasActiveProcess(worktreePath, activeCwds) {
+  if (!Array.isArray(activeCwds)) return true;
   const resolved = canonicalPath(worktreePath);
   const prefix = `${resolved}${path.sep}`;
   return activeCwds.some((cwd) => {
@@ -1223,7 +1314,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
   const worktrees = listWorktrees(root);
   const primary = worktrees[0]?.path ? path.resolve(worktrees[0].path) : '';
   const current = path.resolve(root);
-  const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessCwds();
+  const activeCwds = Array.isArray(activeCwdsOverride) ? activeCwdsOverride.map(canonicalPath) : listActiveProcessPaths();
   const base = normalizeTargetRef(root, baseOverride || defaultShipTarget(root));
   refreshRemoteRef(root, base);
   const candidates = [];
@@ -1258,7 +1349,7 @@ function cleanupWorktrees({ root = repoRoot(), base: baseOverride = '', apply =
       continue;
     }
     if (worktreeHasActiveProcess(wtPath, activeCwds)) {
-      kept.push({ ...item, reason: 'active_process' });
+      kept.push({ ...item, reason: activeCwds ? 'active_process' : 'process_scan_failed' });
       continue;
     }
     const rawCounts = statusCounts(wt.path);
@@ -1438,6 +1529,7 @@ function worktreeCommand(args = []) {
 module.exports = {
   branchName,
   collidingFlights,
+  mergePrWithRetry,
   createAgentWorktree,
   deniedLaneForShip,
   createOrFindPr,
@@ -1448,9 +1540,10 @@ module.exports = {
   gitNetworkEnvironment,
   describeFlightAge,
   flightStampMs,
-  listActiveProcessCwds,
+  listActiveProcessPaths,
   listWorktrees,
   parseAgentFlightName,
+  parseProcessArgPaths,
   parseWorktrees,
   normalizeTargetRef,
   recordWorktreeRemoval,

package/commands/write.js

@@ -341,7 +341,17 @@ function coach(argv, root = process.cwd()) {
 
   if (!offline && claudeAvailable()) {
     const prompt = coachPrompt({ topic, beats, counts, findings, planText, draftText, currentBeat: current.title });
+    // 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(root, { engine: 'claude', task: 'write coach' });
     const res = spawnSync('claude', ['-p', prompt], { encoding: 'utf8', timeout: 120000, maxBuffer: 1024 * 1024 });
+    // spawnSync does not throw, so a failure is passed in the thrown shape.
+    const end = endResource(res.error || res.signal || res.status !== 0 ? {
+      code: res.error && res.error.code,
+      signal: res.signal,
+      stderr: res.stderr,
+      message: res.error ? res.error.message : `claude exited ${res.status}`,
+    } : null);
     const out = (res.stdout || '').trim();
     if (res.status === 0 && /QUESTION:/.test(out)) {
       console.log(out.split('\n').map((l) => `  ${l}`).join('\n'));
@@ -350,7 +360,8 @@ function coach(argv, root = process.cwd()) {
       console.log(`\n  your move: answer under "## ${current.title}" in draft.md, then \`atris write status\`\n`);
       return 0;
     }
-    console.log('  (claude coach unavailable, falling back to the offline coach)\n');
+    const stopped = end && end.cause ? `claude coach stopped by ${res.signal}; ${end.cause}` : 'claude coach unavailable';
+    console.log(`  (${stopped}, falling back to the offline coach)\n`);
   }
 
   // Offline coach: still proactive, still gets you going. Seeds + one question.