atris 3.63.0 → 3.65.0

package/lib/member-identity.js

@@ -0,0 +1,56 @@
+'use strict';
+
+// How a launch names the member it runs as, in one place. The writers use
+// these lines and the team view reads them back with patterns built from the
+// same lines, so the wording cannot drift apart.
+//
+// Mission ticks (atris member run, atris mission) say:
+//   You are the member "validator".
+//   **Objective:** <what the run is for>
+// Dispatch briefs say:
+//   You are acting as validator. <the work>
+
+const escapeRegExp = require('./escape-regexp');
+
+const NAME = '([a-z0-9][a-z0-9_-]*[a-z0-9])';
+const SLOT = '\u0000';
+
+function memberIdentityLine(name) {
+  return `You are the member "${name}".`;
+}
+
+function missionObjectiveLine(objective) {
+  return `**Objective:** ${objective}`;
+}
+
+function patternFrom(line, name) {
+  return new RegExp(escapeRegExp(line).replace(escapeRegExp(SLOT), name), 'i');
+}
+
+const MISSION_MEMBER = patternFrom(memberIdentityLine(SLOT), NAME);
+const DISPATCH_MEMBER = /\bacting as (?:the )?([a-z0-9][a-z0-9_-]*[a-z0-9])[.,:;]?/i;
+const OBJECTIVE = patternFrom(missionObjectiveLine(SLOT), '(.+?)(?=\\s\\*\\*[A-Z][^*]*:\\*\\*|\\s#|$)');
+
+// One prompt -> { member, doing }. The member is the name the prompt runs
+// as, or null. doing is what the run is for: a mission's objective, or the
+// words after the dispatch line.
+function readMemberLaunch(prompt) {
+  const text = String(prompt || '').replace(/\\0?12|\\n/g, ' ').replace(/\s+/g, ' ').trim();
+  const mission = MISSION_MEMBER.exec(text);
+  if (mission) {
+    const objective = OBJECTIVE.exec(text);
+    return { member: mission[1].toLowerCase(), doing: objective ? objective[1].trim() : text };
+  }
+  const dispatch = DISPATCH_MEMBER.exec(text);
+  if (dispatch) {
+    const after = text.slice(dispatch.index + dispatch[0].length).trim();
+    return { member: dispatch[1].toLowerCase(), doing: after || text };
+  }
+  return { member: null, doing: text };
+}
+
+module.exports = {
+  memberIdentityLine,
+  missionObjectiveLine,
+  readMemberLaunch,
+};

package/lib/pack-capabilities.js

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
+const { stateHome } = require('./state-home');
 const dns = require('dns').promises;
 const net = require('net');
 const { randomUUID, createHash } = require('crypto');
@@ -250,7 +251,7 @@ function buildClaudeCapabilityArgs(policy, options = {}) {
 function receiptDirectory(options = {}) {
   if (options.receiptDir) return path.resolve(options.receiptDir);
   if (process.env.ATRIS_PACK_RUNS_DIR) return path.resolve(process.env.ATRIS_PACK_RUNS_DIR);
-  return path.join(os.homedir(), '.atris', 'runs', 'packs');
+  return path.join(stateHome(), '.atris', 'runs', 'packs');
 }
 
 function appendReceiptEvent(eventsPath, event) {

package/lib/permission-grants.js

@@ -8,8 +8,8 @@
 // Design brief: atris/designs/permission-grants-cli-831.md
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
+const { stateHome } = require('./state-home');
 const crypto = require('crypto');
 
 const GRANTS_SCHEMA = 'atris.permission_grants.v1';
@@ -39,7 +39,7 @@ const NEVER_GRANTABLE = [
 
 function grantsFilePath() {
   return process.env.ATRIS_PERMISSION_GRANTS_FILE
-    || path.join(os.homedir(), '.atris', 'permission-grants.json');
+    || path.join(stateHome(), '.atris', 'permission-grants.json');
 }
 
 function parseArgv(command) {

package/lib/pulse.js

@@ -14,8 +14,8 @@
 
 const fs = require('fs');
 const crypto = require('crypto');
-const os = require('os');
 const path = require('path');
+const { stateHome: userStateHome } = require('./state-home');
 const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('./runner-command');
 const { readOrbScorecard } = require('./orb-scorecard');
 
@@ -69,7 +69,7 @@ function pulseRepoSlug(root) {
   return `${base}-${hash}`;
 }
 
-function pulseStateHome(root, homeDir = os.homedir()) {
+function pulseStateHome(root, homeDir = userStateHome()) {
   return path.join(homeDir, '.atris', 'overnight', `pulse-${pulseRepoSlug(root)}`);
 }
 
@@ -77,7 +77,7 @@ function pulseMarker(root) {
   return `ATRIS_PULSE_${pulseRepoSlug(root).toUpperCase().replace(/[^A-Z0-9]+/g, '_')}`;
 }
 
-function legacyPulseStateHome(homeDir = os.homedir()) {
+function legacyPulseStateHome(homeDir = userStateHome()) {
   return path.join(homeDir, '.atris', 'overnight', LEGACY_STATE_DIRNAME);
 }
 
@@ -92,7 +92,7 @@ function readTickScriptRoot(stateHome) {
   }
 }
 
-function legacyPulseStateMatchesRoot(root, homeDir = os.homedir()) {
+function legacyPulseStateMatchesRoot(root, homeDir = userStateHome()) {
   const legacyStateHome = legacyPulseStateHome(homeDir);
   const scriptRoot = readTickScriptRoot(legacyStateHome);
   if (!scriptRoot) return false;
@@ -100,7 +100,7 @@ function legacyPulseStateMatchesRoot(root, homeDir = os.homedir()) {
 }
 
 function resolvePulseSlot(root, options = {}) {
-  const homeDir = options.homeDir || os.homedir();
+  const homeDir = options.homeDir || userStateHome();
   const stateHome = pulseStateHome(root, homeDir);
   const marker = pulseMarker(root);
   const legacyStateHome = legacyPulseStateHome(homeDir);

package/lib/roster-models.js

@@ -97,6 +97,16 @@ function engineRunsView(engineId, { model = '', effort = '' } = {}, options = {}
   return view;
 }
 
+// "<engine> · <model label>" for a table cell: the tool, a middle dot, and the
+// model label, or "own default" when the tool picks its model itself.
+// Effort is left out; tables give it its own line.
+function engineModelText(engine, model = '') {
+  const id = String(engine || '').trim();
+  if (!id) return '';
+  const label = model ? modelLabel(model) : '';
+  return `${id} · ${label || 'own default'}`;
+}
+
 function runsDetail(view) {
   const items = [{ text: view.model ? modelLabel(view.model) : 'its own default', source: view.model ? view.model_source : 'roster' }];
   if (view.effort) items.push({ text: view.effort, source: view.effort_source });
@@ -172,6 +182,7 @@ function availableModels(engines, options = {}) {
 }
 
 module.exports = {
+  engineModelText,
   modelLabel,
   readCodexSettings,
   engineRunsView,

package/lib/roster-runs.js

@@ -29,14 +29,25 @@ const TAIL_BYTES = 512 * 1024;
 const RUNS_ROTATE_BYTES = 2 * 1024 * 1024;
 const JOB_ALIASES = Object.freeze({ navigator: 'search', executor: 'build', builder: 'build', validator: 'review', reviewer: 'review' });
 
+// The record belongs to the project, not to the scratch checkout a run
+// happened in. A fleet build, a mission, or an ask run inside a git worktree
+// writes to the main checkout, so the history survives when the worktree is
+// reaped and `atris engine roster --runs` reads the same file from either
+// place. Same pointer-file lookup the roster and member cards use.
+function runsRoot(root = process.cwd()) {
+  const { mainCheckoutRoot } = require('./engine-registry');
+  const main = mainCheckoutRoot(root);
+  return main && fs.existsSync(main) ? main : root;
+}
+
 function rosterRunsPath(root = process.cwd()) {
-  return path.join(root, RUNS_FILE);
+  return path.join(runsRoot(root), RUNS_FILE);
 }
 
 // Rotated logs, oldest name first; the stamp in each name makes name order
 // the order they were renamed in.
 function rotatedRunsPaths(root = process.cwd()) {
-  const dir = path.dirname(path.join(root, RUNS_FILE));
+  const dir = path.dirname(rosterRunsPath(root));
   let names;
   try {
     names = fs.readdirSync(dir);

package/lib/roster-stale.js

@@ -0,0 +1,241 @@
+'use strict';
+
+// Outdated models on the roster. A roster worker whose model has a newer
+// version among the models this machine or the engine registry already
+// knows gets one plain line and the command that moves it forward. A pinned
+// model whose newest proof (a "verified <date>" on its line, or a landed run
+// on that model) is over 30 days old gets one line too. Nothing here goes
+// online: the model lists come from availableModels (codex's own models
+// cache, the claude names atris knows, and each engine's registry models).
+
+const { modelLabel, availableModels } = require('./roster-models');
+const { parseRosterUntil, rosterMaxText, rosterToolLabel } = require('./engine-registry');
+
+const PIN_MAX_AGE_DAYS = 30;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const CLAUDE_FAMILY = Object.freeze(['claude', 'fable', 'haiku']);
+
+// Family ordering across names is ambiguous: going from a "luna" tail to a
+// "sol" tail one version up is a tier change as much as a version change,
+// and nothing local says which tails rank above which. So versions are only
+// compared within an identical name prefix, the text before the first
+// version number: "x-6-astra" and "x-6.1-sol" share the prefix "x", and two
+// names with different prefixes (sonnet and opus) never compare. Among
+// newer versions, one that keeps the same tail (sol, fast, flash-high) wins;
+// otherwise the highest version, and on a tie the one the list names first.
+// Examples stay abstract here so this file never pins a real model name.
+// A context tag at the end ("[1m]", "(beta)") is not part of the name, and
+// a leading "claude-" before a family word is the vendor, not the family,
+// so "claude-x-4-6[1m]" and "x 5" land in the same family.
+function familyLabel(model) {
+  let text = String(model || '').trim();
+  while (/\s*(?:\[[^\]]*\]|\([^)]*\))$/.test(text)) text = text.replace(/\s*(?:\[[^\]]*\]|\([^)]*\))$/, '');
+  return modelLabel(text).toLowerCase().trim().replace(/^claude[\s_-]+(?=[a-z])/, '');
+}
+
+function modelFamily(model) {
+  const label = familyLabel(model);
+  const match = /^([a-z][a-z/_\s-]*?)[\s_-]*(\d+(?:[.-]\d{1,2}(?!\d))*)(.*)$/.exec(label);
+  if (!match) return null;
+  const prefix = match[1].replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, '');
+  if (!prefix) return null;
+  return {
+    prefix,
+    version: match[2].split(/[.-]/).map(Number),
+    variant: match[3].replace(/[\s_-]+/g, '-').replace(/^-+|-+$/g, ''),
+  };
+}
+
+function compareVersions(a, b) {
+  const size = Math.max(a.length, b.length);
+  for (let i = 0; i < size; i += 1) {
+    const diff = (a[i] || 0) - (b[i] || 0);
+    if (diff) return diff > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+function sameModel(a, b) {
+  const left = modelLabel(a).toLowerCase().trim();
+  return Boolean(left) && left === modelLabel(b).toLowerCase().trim();
+}
+
+// The newest model in the list that beats this one, or null.
+function newerModel(model, catalog = []) {
+  const current = modelFamily(model);
+  if (!current) return null;
+  let best = null;
+  for (const candidate of catalog || []) {
+    const family = modelFamily(candidate);
+    if (!family || family.prefix !== current.prefix) continue;
+    if (compareVersions(family.version, current.version) <= 0) continue;
+    const sameTail = family.variant === current.variant;
+    const better = !best
+      || (sameTail && !best.sameTail)
+      || (sameTail === best.sameTail && compareVersions(family.version, best.family.version) > 0);
+    if (better) best = { candidate, family, sameTail };
+  }
+  return best ? best.candidate : null;
+}
+
+// Every model each engine is known to offer, from local files only. Claude,
+// fable, and haiku run through the same CLI, so they share one list.
+function modelCatalog(engines, options = {}) {
+  const catalog = {};
+  const add = (id, models) => {
+    const list = catalog[id] || (catalog[id] = []);
+    for (const model of models || []) if (model && !list.includes(model)) list.push(model);
+  };
+  const rows = availableModels(engines || [], options);
+  for (const row of rows) add(row.engine, row.models);
+  for (const engine of engines || []) add(engine.id, engine.models);
+  const claude = (rows.find((row) => row.engine === 'claude') || {}).models || [];
+  for (const id of CLAUDE_FAMILY) if (catalog[id]) add(id, claude);
+  return catalog;
+}
+
+function localDayText(date) {
+  const pad = (value) => String(value).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+
+function wholeDaysSince(dayText, now) {
+  const day = parseRosterUntil(dayText);
+  if (!day) return null;
+  const date = new Date(now);
+  const today = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  return Math.round((today.getTime() - day.getTime()) / DAY_MS);
+}
+
+// The newest proof that this engine and model answer: the line's own
+// "verified" date or the newest landed run on the same engine and model.
+function pinVerified(worker, runs) {
+  let best = worker.verified ? { at: worker.verified, source: 'roster line' } : null;
+  for (const run of runs || []) {
+    if (run.outcome !== 'landed' || run.engine !== worker.engine || !sameModel(run.model, worker.model)) continue;
+    const at = Date.parse(run.at);
+    if (!Number.isFinite(at)) continue;
+    const day = localDayText(new Date(at));
+    if (!best || day > best.at) best = { at: day, source: 'landed run' };
+  }
+  return best;
+}
+
+function quoteArg(text) {
+  const value = String(text || '');
+  return /^[A-Za-z0-9._:/@-]+$/.test(value) ? value : `"${value.replace(/"/g, '\\"')}"`;
+}
+
+const SCOPE_FLAGS = Object.freeze({ 'all projects': '--everywhere', 'this session': '--session' });
+
+// The assign command that moves a job's first worker to the newer model and
+// keeps everything else on its line: effort, time cap, prep, end date.
+function assignCommand(row, worker, model) {
+  const parts = ['atris engine assign', quoteArg(row.job), worker.engine, '--model', quoteArg(modelLabel(model))];
+  if (worker.effort) parts.push('--effort', worker.effort);
+  if (worker.max_seconds) parts.push('--max', quoteArg(rosterMaxText(worker.max_seconds).replace(/^max /, '')));
+  if (worker.prep) parts.push('--prep', quoteArg(worker.prep));
+  if (worker.until && Number(worker.ends_in_days) > 0) parts.push('--days', String(worker.ends_in_days));
+  if (SCOPE_FLAGS[row.from]) parts.push(SCOPE_FLAGS[row.from]);
+  return parts.join(' ');
+}
+
+function lineHint(file, line, change) {
+  const where = line ? `line ${line} of ${file || 'the roster'}` : (file || 'the roster');
+  return `${change} on ${where}`;
+}
+
+// Mark every worker and job in a roster report with stale_model,
+// newer_model, pin_age_days, and pin_verified_at, and list what needs a
+// look in report.stale. Returns the report.
+function attachStaleModels(report, { catalog = {}, runs = [], now = new Date() } = {}) {
+  const stale = [];
+  const today = localDayText(new Date(now));
+  for (const row of report.jobs || []) {
+    (row.workers || []).forEach((worker, index) => {
+      worker.stale_model = false;
+      worker.newer_model = null;
+      worker.pin_age_days = null;
+      worker.pin_verified_at = null;
+      const view = worker.runs;
+      if (!view || !view.model || !worker.engine || worker.why === 'expired') return;
+      const who = index === 0 ? row.job : `${row.job} backup`;
+      const tool = rosterToolLabel(worker.engine);
+      const newer = newerModel(view.model, catalog[worker.engine]);
+      if (newer) {
+        worker.stale_model = true;
+        worker.newer_model = newer;
+        const from = view.model_source === 'roster' ? '' : ` from ${view.model_source}`;
+        const renew = index === 0
+          ? assignCommand(row, worker, newer)
+          : lineHint(row.file, worker.line, `change the model to ${modelLabel(newer)}`);
+        stale.push({
+          kind: 'newer model',
+          job: row.job,
+          engine: worker.engine,
+          model: view.model,
+          newer_model: newer,
+          from: row.from,
+          file: row.file,
+          line: worker.line,
+          renew,
+          text: `${who}: ${tool} runs ${modelLabel(view.model)}${from}, newer ${modelLabel(newer)} is available. renew: ${renew}`,
+        });
+      }
+      if (view.model_source !== 'roster') return;
+      const proof = pinVerified({ ...worker, model: view.model }, runs);
+      if (!proof) return;
+      worker.pin_verified_at = proof.at;
+      worker.pin_age_days = wholeDaysSince(proof.at, now);
+      if (worker.pin_age_days === null || worker.pin_age_days <= PIN_MAX_AGE_DAYS || newer) return;
+      stale.push({
+        kind: 'old pin',
+        job: row.job,
+        engine: worker.engine,
+        model: view.model,
+        pin_verified_at: proof.at,
+        pin_age_days: worker.pin_age_days,
+        from: row.from,
+        file: row.file,
+        line: worker.line,
+        text: `${who}: ${tool} on ${modelLabel(view.model)} was last verified ${worker.pin_age_days} days ago (${proof.source}). smoke one prompt, then ${lineHint(row.file, worker.line, `add "verified ${today}"`)}`,
+      });
+    });
+    // The job's own fields mirror the worker that leads it, else its first.
+    const lead = (row.workers || []).find((worker) => worker.status === 'leads') || (row.workers || [])[0] || {};
+    row.stale_model = Boolean(lead.stale_model);
+    row.newer_model = lead.newer_model || null;
+    row.pin_age_days = lead.pin_age_days === undefined ? null : lead.pin_age_days;
+  }
+  // A member line that pins its own model is checked too; a member that
+  // picks automatically runs its job's worker, already checked above.
+  for (const member of report.team || []) {
+    if (member.source !== 'file' || !member.model || !member.engine) continue;
+    const newer = newerModel(member.model, catalog[member.engine]);
+    member.stale_model = Boolean(newer);
+    member.newer_model = newer;
+    if (!newer) continue;
+    const renew = `change the model to ${modelLabel(newer)} on the ${member.member} line of ${member.file || 'the roster'}`;
+    stale.push({
+      kind: 'newer model',
+      member: member.member,
+      engine: member.engine,
+      model: member.model,
+      newer_model: newer,
+      file: member.file,
+      renew,
+      text: `${member.member}: ${rosterToolLabel(member.engine)} runs ${modelLabel(member.model)}, newer ${modelLabel(newer)} is available. renew: ${renew}`,
+    });
+  }
+  report.stale = stale;
+  return report;
+}
+
+module.exports = {
+  PIN_MAX_AGE_DAYS,
+  attachStaleModels,
+  compareVersions,
+  modelCatalog,
+  modelFamily,
+  newerModel,
+};

package/lib/runner-command.js

@@ -87,9 +87,11 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
   }),
   // No hard pin: a pinned grok-4.6 went stale when the grok CLI moved its
   // own default to grok-4.7-build-fast, so an unpinned run rides the CLI.
+  // Grok runs only xAI models, so a claude model name never reaches it.
   grok: Object.freeze({
     bin: 'grok',
     model: '',
+    ownModelsOnly: true,
     commandTemplate: '{bin} --always-approve {pinnedModelFlag} {pinnedEffortFlag} -p {prompt}',
     effortFlag: '--reasoning-effort',
     efforts: Object.freeze(['low', 'medium', 'high']),
@@ -213,6 +215,17 @@ function resolvePinnedRunnerModel(mission) {
   return explicit || runnerProfileValue('model');
 }
 
+// The own-models-only engine a runner bin launches ("codex", "/opt/bin/grok"),
+// or '' when the program is not one of them.
+function ownModelsOnlyEngineForBin(bin) {
+  const name = String(bin || '').split(/[\\/]/).pop().replace(/\.exe$/i, '').toLowerCase();
+  if (!name) return '';
+  return Object.keys(RUNNER_PROFILE_DEFS).find((id) => {
+    const def = RUNNER_PROFILE_DEFS[id];
+    return def.ownModelsOnly && def.bin === name;
+  }) || '';
+}
+
 // The model an engine is launched with. An engine that runs only its own
 // vendor's models drops a claude model name (a mission's stored default, a
 // claude env pin) and rides its own default instead.
@@ -321,12 +334,13 @@ function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
   }
   const resolved = resolveClaudeRunnerModel({ model });
   const template = resolveClaudeRunnerCommandTemplate();
+  // Both the profile and the program that actually runs count: a runner bin
+  // named codex or grok (or a path ending in one) is that engine under any
+  // profile, with or without a template.
+  const profile = resolveRunnerProfileName();
+  const binEngine = ownModelsOnlyEngineForBin(resolveClaudeRunnerBin());
+  const modelFor = (value) => runnerModelFor(binEngine, runnerModelFor(profile, value));
   if (template) {
-    // Both the profile and the program that actually runs count: a runner
-    // bin named codex (or a path ending in it) is codex under any profile.
-    const profile = resolveRunnerProfileName();
-    const binName = String(resolveClaudeRunnerBin()).split(/[\\/]/).pop();
-    const modelFor = (value) => runnerModelFor(binName, runnerModelFor(profile, value));
     return renderRunnerCommandTemplate(template, {
       promptFile,
       allowedTools,
@@ -336,7 +350,9 @@ function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
     });
   }
   const safePath = String(promptFile).replace(/'/g, "'\\''");
-  let cmd = `${shellWord(resolveClaudeRunnerBin())} -p "$(cat '${safePath}')" --model ${shellWord(resolved)}`;
+  const launchModel = modelFor(resolved);
+  let cmd = `${shellWord(resolveClaudeRunnerBin())} -p "$(cat '${safePath}')"`;
+  if (launchModel) cmd += ` --model ${shellWord(launchModel)}`;
   const effortFlag = runnerEffortFlag(effort);
   if (effortFlag) cmd += ` ${effortFlag}`;
   if (allowedTools) {

package/lib/sandbox-pids.js

@@ -0,0 +1,113 @@
+'use strict';
+
+// Find every process a sealed run may have left behind: members of its
+// process group, holders of its lease file, and anything whose cwd sits in its
+// worktree. Each lsof scan walks the whole process table (about 300 to 500ms on
+// a busy mac), and the reaper repeats the sweep six times per sealed run, so
+// the three scans run side by side instead of one after another. They run from
+// "/" so a scan never finds its own siblings through the worktree cwd.
+
+const { spawn, spawnSync } = require('node:child_process');
+
+function sandboxPidQueries({ pgid, leaseFile, cwd }) {
+  const queries = [];
+  const group = Number(pgid);
+  if (Number.isInteger(group) && group > 0) queries.push(['/usr/bin/pgrep', ['-g', String(group)]]);
+  queries.push(['/usr/sbin/lsof', ['-t', String(leaseFile)]]);
+  if (cwd) queries.push(['/usr/sbin/lsof', ['-a', '-d', 'cwd', '+D', String(cwd), '-t']]);
+  return queries;
+}
+
+function collectPids(outputs, excluded) {
+  const pids = new Set();
+  for (const output of outputs) {
+    for (const value of String(output || '').trim().split(/\s+/)) {
+      const pid = Number(value);
+      if (Number.isInteger(pid) && pid > 0) pids.add(pid);
+    }
+  }
+  for (const pid of excluded) pids.delete(pid);
+  return [...pids];
+}
+
+// pgrep and lsof both exit 1 when nothing matches. Anything else (another
+// status, a signal, a spawn error, no stdout pipe) means the scan did not run,
+// which is not the same as finding nothing.
+function runScan(bin, argv) {
+  return new Promise((resolve) => {
+    let stdout = '';
+    let settled = false;
+    const finish = (ok) => {
+      if (settled) return;
+      settled = true;
+      resolve({ ok, stdout: ok ? stdout : '' });
+    };
+    let child;
+    try {
+      child = spawn(bin, argv, { cwd: '/', stdio: ['ignore', 'pipe', 'ignore'] });
+    } catch {
+      finish(false);
+      return;
+    }
+    child.once('error', () => finish(false));
+    if (!child.stdout) {
+      finish(false);
+      return;
+    }
+    child.stdout.on('error', () => finish(false));
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.once('close', (status, signal) => finish(!signal && (status === 0 || status === 1)));
+  });
+}
+
+function sequentialOutputs(query) {
+  return sandboxPidQueries(query).map(([bin, argv]) => {
+    try {
+      return spawnSync(bin, argv, { cwd: '/', encoding: 'utf8' }).stdout;
+    } catch {
+      return '';
+    }
+  });
+}
+
+// If any side-by-side scan fails, run the whole sweep again one by one and
+// keep every pid either pass saw.
+async function trackedSandboxPids(query, { excluded = [process.pid], scan = runScan } = {}) {
+  const scans = await Promise.all(sandboxPidQueries(query).map(([bin, argv]) => scan(bin, argv)));
+  const outputs = scans.map((result) => result.stdout);
+  if (scans.some((result) => !result.ok)) outputs.push(...sequentialOutputs(query));
+  return collectPids(outputs, excluded);
+}
+
+// Synchronous callers get the same parallel sweep through one short node
+// helper. If the helper cannot answer, fall back to the one-by-one sweep so
+// the reaper never runs blind.
+function trackedSandboxPidsSync(query) {
+  const excluded = [process.pid];
+  const helper = spawnSync(process.execPath, [__filename, JSON.stringify(query)], {
+    cwd: '/',
+    encoding: 'utf8',
+  });
+  if (helper.status === 0) {
+    try {
+      const parsed = JSON.parse(helper.stdout);
+      if (Array.isArray(parsed)) {
+        return collectPids([parsed.join(' ')], [...excluded, helper.pid]);
+      }
+    } catch {}
+  }
+  return collectPids(sequentialOutputs(query), excluded);
+}
+
+if (require.main === module) {
+  trackedSandboxPids(JSON.parse(process.argv[2] || '{}'))
+    .then((pids) => { process.stdout.write(JSON.stringify(pids) + '\n'); })
+    .catch(() => { process.exitCode = 1; });
+}
+
+module.exports = {
+  runScan,
+  trackedSandboxPids,
+  trackedSandboxPidsSync,
+};

package/lib/secret-gateway.js

@@ -393,6 +393,7 @@ function buildGatewaySupervisorScript(gatewayModulePath) {
     "const fs = require('node:fs');",
     "const { spawn, spawnSync } = require('node:child_process');",
     `const sg = require(${JSON.stringify(gatewayModulePath)});`,
+    `const sandboxPids = require(${JSON.stringify(require.resolve('./sandbox-pids'))});`,
     "const [exitFile, stateFile, leaseFile, statusFile, executable, ...args] = process.argv.slice(2);",
     "const leaseFd = fs.openSync(leaseFile, 'w', 0o600);",
     "const statusFd = fs.openSync(statusFile, 'w', 0o600);",
@@ -413,18 +414,7 @@ function buildGatewaySupervisorScript(gatewayModulePath) {
     "  fs.writeFileSync(stateFile, JSON.stringify({ pgid: child.pid, cwd: process.cwd() }) + '\\n', { mode: 0o600 });",
     '  let stopping = false;',
     '  const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));',
-    '  function trackedPids() {',
-    '    const pids = new Set();',
-    "    for (const [bin, argv] of [['/usr/bin/pgrep', ['-g', String(child.pid)]], ['/usr/sbin/lsof', ['-t', leaseFile]], ['/usr/sbin/lsof', ['-a', '-d', 'cwd', '+D', process.cwd(), '-t']]]) {",
-    "      const found = spawnSync(bin, argv, { encoding: 'utf8' });",
-    "      for (const value of String(found.stdout || '').trim().split(/\\s+/)) {",
-    '        const pid = Number(value);',
-    '        if (Number.isInteger(pid) && pid > 0) pids.add(pid);',
-    '      }',
-    '    }',
-    '    pids.delete(process.pid);',
-    '    return [...pids];',
-    '  }',
+    '  const trackedPids = () => sandboxPids.trackedSandboxPids({ pgid: child.pid, leaseFile, cwd: process.cwd() });',
     '  async function stop(code) {',
     '    if (stopping) return;',
     '    stopping = true;',
@@ -433,7 +423,7 @@ function buildGatewaySupervisorScript(gatewayModulePath) {
     '    }',
     "    for (const [signal, delay] of [['SIGTERM', 100], ['SIGKILL', 100], ['SIGKILL', 100]]) {",
     '      try { process.kill(-child.pid, signal); } catch {}',
-    '      for (const pid of trackedPids()) { try { process.kill(pid, signal); } catch {} }',
+    '      for (const pid of await trackedPids()) { try { process.kill(pid, signal); } catch {} }',
     '      await wait(delay);',
     '    }',
     '    try { await gateway.close(); } catch {}',