atris 3.58.8 → 3.60.0

package/lib/feedback-triage.js

@@ -183,9 +183,11 @@ async function dispatchFeedbackTriage(brief, workspace, deps = {}) {
     : resolveEngine('executor', workspace, 'codex', { taskType: 'feedback_triage', lowStakes: true });
   const engine = selected && selected.engine && selected.engine.id;
   if (!engine) throw new Error('feedback triage found no ready engine');
+  const model = selected.engine.roster_model || '';
 
   const answers = await dispatch([{
     engine,
+    ...(model ? { model } : {}),
     prompt: brief.prompt,
     label: `feedback ${brief.feedback_id}`,
   }], {

package/lib/fleet.js

@@ -37,6 +37,7 @@ const { sleepSync } = require('./sleep-sync');
 const { ownerIdentity } = require('../utils/owner-identity');
 const { matchTaste } = require('./taste-lessons');
 const { buildVerifiedScoutPack, appendVerifiedScoutPack } = require('./dispatch-scout');
+const { mapNotesPath } = require('./map-refs');
 const {
   applySecretGrantEnvironment,
   buildGatewaySupervisorScript,
@@ -110,7 +111,9 @@ function buildFleetPrompt(task, { worktreePath, yolo = false } = {}) {
   lines.push(`Check: ${check}`, '');
   lines.push(
     'Rules:',
-    '- Read atris/MAP.md first to locate the code; never guess file locations.',
+    mapNotesPath(worktreePath || process.cwd())
+      ? '- Read atris/MAP.md first to locate the code, then atris/refs/MAP-NOTES.md for exact file:line refs; never guess file locations.'
+      : '- Read atris/MAP.md first to locate the code; never guess file locations.',
     '- Keep one concern per PR; split anything larger into separate PRs because git history guides future agents and small PRs are cheap to revert and bisect.',
     '- Run git status first. Stage ONLY files you changed. Never revert or touch files another agent modified.',
     '- Include or update a focused regression test; run it with npm run test:fast && node --test <focused files> before committing.',
@@ -205,21 +208,37 @@ function assertIsolatedWorktree(worktreePath, root = process.cwd()) {
   return { worktreePath: resolvedWorktree, primaryRoot };
 }
 
-function wrapCodexWithWatchdog(cmd, watchdogPath = CODEX_WATCHDOG_SOURCE, receiptPath = '') {
+// A roster time cap, in whole seconds, or 0 when none is set.
+function capSeconds(value) {
+  const seconds = Math.floor(Number(value));
+  return Number.isFinite(seconds) && seconds > 0 ? seconds : 0;
+}
+
+// The pin a validator runs with: a model string (older callers) or
+// { model, effort, max_seconds } from the roster.
+function validatorPin(validatorModels, engine) {
+  const pin = validatorModels && validatorModels[engine];
+  if (!pin) return { model: '', effort: '', maxSeconds: 0 };
+  if (typeof pin === 'string') return { model: pin, effort: '', maxSeconds: 0 };
+  return { model: String(pin.model || ''), effort: String(pin.effort || ''), maxSeconds: capSeconds(pin.max_seconds) };
+}
+
+function wrapCodexWithWatchdog(cmd, watchdogPath = CODEX_WATCHDOG_SOURCE, receiptPath = '', maxSeconds = 0) {
   // Codex hangs forever at startup when stdin is an open pipe (three real
   // flights on 2026-08-11 sat 50-100 minutes at zero CPU). Force every fleet
   // codex spawn through the silent-start / runtime-cap watchdog with stdin
   // sealed, so orchestrator prompts cannot forget the convention.
   const receiptArg = receiptPath ? ` --receipt ${shellSingleQuote(receiptPath)}` : '';
-  return `${shellSingleQuote(process.execPath)} ${shellSingleQuote(watchdogPath)} --startup-deadline 90 --max-runtime 3600${receiptArg} -- sh -c ${shellSingleQuote(cmd)} </dev/null`;
+  const maxRuntime = capSeconds(maxSeconds) || 3600;
+  return `${shellSingleQuote(process.execPath)} ${shellSingleQuote(watchdogPath)} --startup-deadline 90 --max-runtime ${maxRuntime}${receiptArg} -- sh -c ${shellSingleQuote(cmd)} </dev/null`;
 }
 
-function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = false, allowedTools = FLEET_ALLOWED_TOOLS, watchdogPath = CODEX_WATCHDOG_SOURCE, watchdogReceiptPath = '' } = {}) {
+function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = false, allowedTools = FLEET_ALLOWED_TOOLS, watchdogPath = CODEX_WATCHDOG_SOURCE, watchdogReceiptPath = '', model = '', effort = '', maxSeconds = 0 } = {}) {
   if (!RUNNER_PROFILE_DEFS[engineName]) throw new Error(`unknown engine "${engineName}"`);
   const prev = process.env.ATRIS_RUNNER_PROFILE;
   process.env.ATRIS_RUNNER_PROFILE = engineName;
   try {
-    let cmd = buildRunnerCommand({ promptFile, allowedTools });
+    let cmd = buildRunnerCommand({ promptFile, allowedTools, ...(model ? { model } : {}), ...(effort ? { effort } : {}) });
     // devin's default is read-only for writes; fleet builds ALWAYS run in an
     // isolated worktree, so the conductor grants write permission here and
     // only here (the profile itself stays safe for non-worktree ticks).
@@ -243,7 +262,7 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     if (yolo && engineName === 'codex') cmd = cmd.replace(/\bexec\b/, `exec ${YOLO_ENGINE_FLAGS.codex}`);
     if (yolo && (engineName === 'claude' || engineName === 'fable')) cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
     if (yolo && engineName === 'commandcode') cmd = `${cmd} --yolo`;
-    if (engineName === 'codex') cmd = wrapCodexWithWatchdog(cmd, watchdogPath, watchdogReceiptPath);
+    if (engineName === 'codex') cmd = wrapCodexWithWatchdog(cmd, watchdogPath, watchdogReceiptPath, maxSeconds);
     return cmd;
   } finally {
     if (prev === undefined) delete process.env.ATRIS_RUNNER_PROFILE;
@@ -303,6 +322,10 @@ function terminateSameSandboxProfile(executable, args, options) {
   });
 }
 
+// Every parent signal guard a dispatch installs, so one dispatch can tell
+// another dispatch's guard from a handler someone else added.
+const DISPATCH_PARENT_GUARDS = new WeakSet();
+
 function spawnWithOutputChunks(executable, args, options = {}) {
   const {
     encoding,
@@ -311,8 +334,13 @@ function spawnWithOutputChunks(executable, args, options = {}) {
     timeout,
     ...childOptions
   } = options;
+  // detached makes the child its own process-group leader, so a time cap can
+  // stop the engine the shell launched and not just the shell. Windows has no
+  // process groups and keeps the direct child kill.
+  const processGroups = process.platform !== 'win32';
   const child = spawn(executable, args, {
     ...childOptions,
+    detached: processGroups,
     stdio: [input == null ? 'ignore' : 'pipe', 'pipe', 'pipe'],
   });
   if (input != null && child.stdin) {
@@ -320,6 +348,53 @@ function spawnWithOutputChunks(executable, args, options = {}) {
     child.stdin.end(input);
   }
 
+  const killChild = () => {
+    if (!processGroups) {
+      try { child.kill('SIGKILL'); } catch {}
+      return;
+    }
+    try { process.kill(-child.pid, 'SIGKILL'); } catch { try { child.kill('SIGKILL'); } catch {} }
+  };
+  // If this process dies while the child runs, take the child's group down
+  // with it so an interrupted dispatch does not orphan the engine. A detached
+  // child leads its own group, so the terminal's Ctrl-C never reaches it, and
+  // Node's default signal exit skips 'exit' listeners. Guard the termination
+  // signals too: kill the group, drop every listener this dispatch added,
+  // then re-raise the same signal so the parent still dies the way it would
+  // have. Re-raise only when nothing but dispatch guards listened when this
+  // one installed, and nothing listens now: a handler added with
+  // process.once has already removed itself by the time this runs, and its
+  // async cleanup owns exiting. Other dispatches' guards do not count at
+  // install, so the last of several running dispatches still re-raises.
+  const killGroupOnParentExit = () => {
+    try { process.kill(-child.pid, 'SIGKILL'); } catch {}
+  };
+  const parentGuards = [['exit', killGroupOnParentExit]];
+  const othersAtInstall = new Map();
+  const setParentGuards = (install) => {
+    for (const [event, handler] of parentGuards) {
+      if (install) {
+        othersAtInstall.set(event, process.listeners(event).filter((fn) => !DISPATCH_PARENT_GUARDS.has(fn)).length);
+        DISPATCH_PARENT_GUARDS.add(handler);
+        process.on(event, handler);
+      } else {
+        process.removeListener(event, handler);
+      }
+    }
+  };
+  for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    parentGuards.push([signal, () => {
+      killGroupOnParentExit();
+      setParentGuards(false);
+      if (othersAtInstall.get(signal) === 0 && process.listenerCount(signal) === 0) {
+        process.kill(process.pid, signal);
+      }
+    }]);
+  }
+  if (processGroups && typeof child.pid === 'number') {
+    setParentGuards(true);
+  }
+
   const stdoutChunks = [];
   const stderrChunks = [];
   let spawnError = null;
@@ -337,11 +412,12 @@ function spawnWithOutputChunks(executable, args, options = {}) {
       ? setTimeout(() => {
         timeoutError = new Error('spawn ETIMEDOUT');
         timeoutError.code = 'ETIMEDOUT';
-        try { child.kill('SIGKILL'); } catch {}
+        killChild();
       }, Number(timeout))
       : null;
     child.once('close', (status, signal) => {
       if (timer) clearTimeout(timer);
+      setParentGuards(false);
       const encode = (chunks) => {
         const output = Buffer.concat(chunks);
         return encoding ? output.toString(encoding) : output;
@@ -761,7 +837,7 @@ async function dispatchEntryWithRestaff({
 // injectable for tests. `prompt` is injectable too: a caller-supplied prompt
 // (e.g. `atris engine dispatch --prompt-file`) skips the generated
 // buildFleetPrompt text entirely.
-function dispatchToEngine({ task, engine, worktreePath, root = process.cwd(), timeoutMs = null, runner = null, prompt: promptOverride = '', yolo = false, sealed = false, briefId = '', skipBriefCapture = false, environment = null, allowedTools = FLEET_ALLOWED_TOOLS, liveLogPath = '' }) {
+function dispatchToEngine({ task, engine, worktreePath, root = process.cwd(), timeoutMs = null, runner = null, prompt: promptOverride = '', yolo = false, sealed = false, briefId = '', skipBriefCapture = false, environment = null, allowedTools = FLEET_ALLOWED_TOOLS, liveLogPath = '', model = '', effort = '', maxSeconds = 0 }) {
   assertIsolatedWorktree(worktreePath, root);
   const prompt = promptOverride || buildFleetPrompt(task, { worktreePath, yolo });
   let capturedBriefId = briefId;
@@ -788,10 +864,17 @@ function dispatchToEngine({ task, engine, worktreePath, root = process.cwd(), ti
     allowedTools,
     watchdogPath,
     watchdogReceiptPath: watchdogArtifact,
+    model,
+    effort,
+    maxSeconds,
   });
-  const dispatchTimeoutMs = timeoutMs === null || timeoutMs === undefined
-    ? (engine === 'codex' ? CODEX_DISPATCH_TIMEOUT_MS : DEFAULT_DISPATCH_TIMEOUT_MS)
-    : timeoutMs;
+  // A roster time cap replaces the default backstop. Codex keeps a minute of
+  // slack past its watchdog so the watchdog's own receipt gets written.
+  const cap = capSeconds(maxSeconds);
+  const defaultTimeoutMs = cap
+    ? cap * 1000 + (engine === 'codex' ? 60000 : 0)
+    : (engine === 'codex' ? CODEX_DISPATCH_TIMEOUT_MS : DEFAULT_DISPATCH_TIMEOUT_MS);
+  const dispatchTimeoutMs = timeoutMs === null || timeoutMs === undefined ? defaultTimeoutMs : timeoutMs;
   const exec = runner || ((cmd) => {
     const childEnv = sealed && environment
       ? { ...environment }
@@ -2130,6 +2213,7 @@ async function runIndependentValidator({
   validatorEngines,
   validatorDispatcher = null,
   stateInspector = reviewWorktreeSnapshot,
+  validatorModels = null,
 }) {
   const candidates = [...new Set((validatorEngines || []).map((value) => String(value || '').trim()).filter(Boolean))]
     .filter((name) => RUNNER_PROFILE_DEFS[name] && name !== executorEngine);
@@ -2152,6 +2236,7 @@ async function runIndependentValidator({
     };
   }
   const dispatch = validatorDispatcher || ((entry) => Promise.resolve(dispatchToEngine({
+    ...validatorPin(validatorModels, entry.engine),
     task,
     engine: entry.engine,
     worktreePath,
@@ -2828,6 +2913,13 @@ async function runDispatchFlight({
   validatorDispatcher = null,
   validatorStateInspector = null,
   scoutAsk = null,
+  // Pinned model, effort, and time cap for the requested engine only; a
+  // restaffed fallback engine runs on its own defaults. validatorModels maps
+  // a validator engine to its model, or to { model, effort, max_seconds }.
+  model = '',
+  effort = '',
+  maxSeconds = 0,
+  validatorModels = null,
 } = {}) {
   if (!engine) throw new Error('runDispatchFlight: engine is required');
   if (!DISPATCH_CAPABLE.includes(engine)) {
@@ -2985,6 +3077,9 @@ async function runDispatchFlight({
       briefId: entry.brief_id,
       skipBriefCapture: true,
       liveLogPath,
+      model: entry.engine === engine ? model : '',
+      effort: entry.engine === engine ? effort : '',
+      maxSeconds: entry.engine === engine ? maxSeconds : 0,
     }));
   }));
   const restaffState = { used: false };
@@ -3272,6 +3367,7 @@ async function runDispatchFlight({
             validatorEngines,
             validatorDispatcher,
             stateInspector: validatorStateInspector || reviewWorktreeSnapshot,
+            validatorModels,
           });
           validatorResult = validation.validator_result;
           flight.validator_result = validatorResult;