atris 3.57.3 → 3.58.5

package/lib/accept-verify-gate.js

@@ -57,7 +57,7 @@ function placeholderIssue(command) {
 
 function nonFalsifyingIssue(command) {
   if (NON_FALSIFYING_COMMANDS.some((re) => re.test(command.trim()))) {
-    return `\`${command.trim()}\` cannot fail for the reason this task exists — it passes on a commit that deletes the work`;
+    return `\`${command.trim()}\` cannot fail for the reason this task exists, it passes on a commit that deletes the work`;
   }
   return '';
 }
@@ -83,8 +83,8 @@ function evaluateAcceptVerify(task, workspaceRoot, { cache = null } = {}) {
   // Two different questions got fused here at first: "can this fail?" and "is this
   // safe to execute at accept time?". Only the first is this gate's business.
   // Refusing everything outside the execution allow-list flagged 455 accepted tasks,
-  // and sampling them found ordinary verifiers — `npm run type-check`, `npx vitest
-  // run` — sitting beside real prose. A gate that blocks real work gets switched off.
+  // and sampling them found ordinary verifiers: `npm run type-check`, `npx vitest
+  // run` sitting beside real prose. A gate that blocks real work gets switched off.
   // So: refuse what provably cannot fail, run what can be run safely, and mark the
   // rest unchecked rather than pretend a judgment we cannot make.
   const parsed = parseVerifyCommand(command);

package/lib/activity-stream.js

@@ -3,7 +3,7 @@
 // Activity stream: normalize the workspace's receipt channels into ONE
 // time-ordered feed of what the agent actually did, plus a heartbeat summary.
 // The task board shows a static inventory of tasks; this turns the same data
-// into "what happened, in order" — the stream you watch for hours.
+// into "what happened, in order": the stream you watch for hours.
 
 const TS_KEYS = ['ts', 'at', 'created_at', 'accepted_at', 'timestamp', 'updated_at'];
 

package/lib/apply-gate.js

@@ -95,8 +95,21 @@ function ensureApply({
   return required ? 2 : 0;
 }
 
+function ephemeralApplyMessage(kind) {
+  const label = String(kind || '').trim() || 'result';
+  return `next: write one apply (change + receipt) for this ${label}`;
+}
+
+function hintEphemeralApply(output, kind) {
+  const print = typeof output === 'function' ? output : (line = '') => console.error(line);
+  print(ephemeralApplyMessage(kind));
+  return 0;
+}
+
 module.exports = {
   applySlug,
   applySidecarRel,
   ensureApply,
+  ephemeralApplyMessage,
+  hintEphemeralApply,
 };

package/lib/auto-accept-certified.js

@@ -11,6 +11,18 @@ const { policyLessonsForFiles, readPolicyLessons } = require('./policy-lessons')
 const { skillEvalGate } = require('./skill-eval-gate');
 
 const AGENT_CERTIFICATION_REVIEW_PASSES = 2;
+
+// Verifier wall clock. The old flat 120s ceiling was measured against this
+// workspace's real suites: the largest single test file needs ~123s and
+// `npm run test` needs ~268s, so honest full-suite proofs could never land.
+// Default is now 10 minutes with an ATRIS_VERIFY_TIMEOUT_MS override; agents
+// should still prefer fast single-file verifiers, but a slow honest check
+// must time out as "too slow", never silently fail as "unproven".
+const DEFAULT_VERIFY_TIMEOUT_MS = 10 * 60 * 1000;
+function verifyTimeoutMs() {
+  const raw = Number(process.env.ATRIS_VERIFY_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? Math.min(raw, 60 * 60 * 1000) : DEFAULT_VERIFY_TIMEOUT_MS;
+}
 // Kept for compat with older callers/tests; the pass-count landing lane it
 // once powered is gone. Passes alone never land work, an independent
 // reviewer does.
@@ -451,7 +463,7 @@ function isAutoCertifyVerifyCommandAllowed(verify) {
 
 // Re-entrancy guard: every verify child carries ATRIS_VERIFY_IN_PROGRESS=1
 // (see verifyCommandEnv). A verify that shells back into the CLI and reaches
-// another verify would otherwise recurse without bound — that cycle
+// another verify would otherwise recurse without bound, that cycle
 // fork-bombed the fleet on 2026-07-29 when a stored pytest called
 // `atris task status` and the read path re-ran the verify. Refuse loudly.
 const VERIFY_IN_PROGRESS_ENV = 'ATRIS_VERIFY_IN_PROGRESS';
@@ -497,7 +509,7 @@ function runVerifyCommand(verify, workspaceRoot) {
     env: verifyCommandEnv(parsed.env),
     shell: false,
     encoding: 'utf8',
-    timeout: 120000,
+    timeout: verifyTimeoutMs(),
   });
   // "I could not run the check" is not "the check failed". Collapsing the two
   // let a broken harness read as broken code: under cron's PATH every
@@ -526,7 +538,7 @@ function runVerifyCommand(verify, workspaceRoot) {
 }
 
 // Verifiers run with shell:false, so the child gets no PATH resolution beyond
-// whatever the parent inherited. Cron has no Homebrew PATH — that is why every
+// whatever the parent inherited. Cron has no Homebrew PATH, that is why every
 // cron entry hardcodes an absolute node path. `npm`, `npx` and friends live in
 // the same bin directory as the node binary currently executing, so seeding
 // PATH with it makes recorded checks runnable from cron with zero config: no
@@ -540,11 +552,15 @@ function verifyCommandEnv(extraEnv) {
     base.PATH = current ? `${binDir}${path.delimiter}${current}` : binDir;
   }
   base[VERIFY_IN_PROGRESS_ENV] = '1';
+  // A verifier that inherits a test-runner context joins the outer runner as
+  // a child and reports instant exit 0 without running anything. Strip it so
+  // recorded checks are real runs, not phantom passes.
+  delete base.NODE_TEST_CONTEXT;
   return base;
 }
 
-// ENOENT: the binary is not on PATH at all. ETIMEDOUT: the 120s ceiling cut it
-// off before it could reach a verdict. Neither is evidence about the diff.
+// ENOENT: the binary is not on PATH at all. ETIMEDOUT: the verify ceiling cut
+// it off before it could reach a verdict. Neither is evidence about the diff.
 function unrunnableVerifyReason(result) {
   const code = result && result.error ? result.error.code : null;
   if (code === 'ENOENT') return 'command_not_found';
@@ -567,7 +583,7 @@ function runVerifyCommandCached(verify, workspaceRoot, cache = null) {
 
 // Pre-land hygiene: dead exports used to surface only AFTER landing, when the
 // full suite's repo-hygiene ratchet went red on master (lesson:
-// engine-dead-exports — engines export every internal helper, the task's own
+// engine-dead-exports: engines export every internal helper, the task's own
 // verify command stays green, and the breakage lands). In repos that carry the
 // ratchet (test/repo-hygiene.test.js), run the same detector before landing so
 // the gate refuses the work instead of master discovering it. Memoized per
@@ -602,7 +618,7 @@ function repoHygieneGate(workspaceRoot) {
         }
         : { ok: true };
     } catch (err) {
-      // "I could not run the detector" is not a verdict on the work — same
+      // "I could not run the detector" is not a verdict on the work, same
       // rule as verify_unrunnable, but hygiene is a repo-wide ratchet the
       // suite still enforces, so failing open here only delays the red.
       result = { ok: true, skipped: true, error: String((err && err.message) || err).slice(0, 200) };
@@ -948,7 +964,7 @@ function receiptEvidenceBlock(task, ref) {
 }
 
 // Authors declare protected lanes in the task text, not the tag field. Match
-// only explicit, deliberate declarations — an unanchored "security" would
+// only explicit, deliberate declarations, an unanchored "security" would
 // snag every task that merely mentions the word and wedge the loop shut,
 // which is its own failure mode. Kept narrow on purpose.
 const PROTECTED_LANE_PHRASES = [
@@ -979,7 +995,7 @@ function declaredProtectedLane(task) {
 
 // Only consulted when a task carries no tag at all, so this never overrides an
 // author who did classify their work. Terms are concrete nouns from the denied
-// lanes — things you can only be touching on purpose. Deliberately excludes
+// lanes: things you can only be touching on purpose. Deliberately excludes
 // broad words like "auth", "user", or "api" that appear in ordinary frontend
 // work and would hold the whole queue.
 const PROTECTED_LANE_TERMS = [
@@ -1051,12 +1067,12 @@ function evaluateAutoAccept(task, options = {}) {
   }
 
   // accept-all: the protected lanes above are the only human gate. No
-  // certification, pass-count, reviewer, or proof-quality bar — but work
+  // certification, pass-count, reviewer, or proof-quality bar, but work
   // is never marked done against evidence it isn't: a proof naming an
   // unmerged draft PR still blocks, and a recorded check that FAILS still
   // blocks (absence of a check does not).
   if (acceptAll) {
-    // In this lane the tag IS the safety system — the only human gate. But
+    // In this lane the tag IS the safety system, the only human gate. But
     // most rows carry no tag at all (13 of 16 in the 2026-07-25 sweep), so
     // refusing every untagged task would wedge the loop shut, which is the
     // same outage as failing open, just quieter. Instead: when there is no
@@ -1096,7 +1112,7 @@ function evaluateAutoAccept(task, options = {}) {
     if (verify && executeVerify) {
       const verifyResult = runVerifyCommandCached(verify, task.workspace_root || process.cwd(), verifyCache);
       // A check that runs and fails blocks. So does a check whose worktree
-      // is gone — otherwise the daily reap converts "has a failing check"
+      // is gone, otherwise the daily reap converts "has a failing check"
       // into "lands unchecked" the morning after it clears the worktree.
       // A check that merely isn't in the runnable allowlist counts as no
       // check at all.

package/lib/autoland.js

@@ -69,7 +69,7 @@ function writeJson(file, value) {
 }
 
 // Default is ON: agents are good enough that a growing review queue is
-// latency, not safety — the denied tags keep the irreversible lanes human.
+// latency, not safety. The denied tags keep the irreversible lanes human.
 // A missing policy file means "on, owner inferred"; only an explicit
 // `atris autoland off` (enabled: false) turns it off.
 function inferOwner(root) {
@@ -157,7 +157,7 @@ function heartbeatStatusText(root, policy) {
     : ageHours < 1 ? 'under an hour' : `${Math.floor(ageHours)}h`;
   // Evidence first: a receipt from the last couple of hours proves the loop is
   // alive no matter what the policy file remembers. The hourly cron makes two
-  // missed hours an outage rather than jitter — and a heartbeat that has gone
+  // missed hours an outage rather than jitter, and a heartbeat that has gone
   // quiet is the single most useful thing this line can say, because that is
   // the state nobody notices.
   if (ageHours !== null && ageHours <= HEARTBEAT_LIVE_HOURS) return `running hourly (last tick ${ageText} ago)`;
@@ -236,7 +236,7 @@ function waitingHours(task, now = Date.now()) {
   return Math.floor((now - certifiedAtMs(task)) / 3600000);
 }
 
-// Tasks that are certified and pending — i.e. finished work sitting on the
+// Tasks that are certified and pending, finished work sitting on the
 // human side of the fence, whatever the reason.
 function waitingOnHuman(tasks, now = Date.now()) {
   return (tasks || [])
@@ -508,7 +508,7 @@ function dejargon(line, options = {}) {
 // The clarity gate in one call: strip what an operator can't act on (flag
 // dashes, task ids, snake_case) and close the sentence on a whole clause, so
 // any title or line borrowed from the queue reaches a human actionable at a
-// glance. One sentence in, one operator-ready sentence out — content always
+// glance. One sentence in, one operator-ready sentence out. Content always
 // ships, the gate only changes how it reads.
 function clarify(text, max = 160) {
   return finishThought(dejargon(text), max);
@@ -538,7 +538,7 @@ function memberTrustLabel(member, root) {
 
 // Short enough for one iMessage, plain enough to read walking to the car.
 // Every line answers: what happened, how big, how we know. It names the work
-// because "7 things landed" tells the score, not the story — and it always
+// because "7 things landed" tells the score, not the story, and it always
 // ends with what's waiting and what to do next, because those are the only
 // lines that ask anything of the reader.
 function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes = [], landed, project, nextMoves = [], acceptAll = false, reapError = null, janitor = null, landingSweep = null, fullStory = false, root = process.cwd() }) {
@@ -620,7 +620,7 @@ function composeDigest({ accepted, waiting, protectedWaiting = [], waitingWishes
   }
   // nextMoves: array of {title, owner}, or {moves, unexplained} where
   // unexplained counts queue items whose sentence carries no operator why.
-  // Those are counted, not shown — a raw title the reader can't act on is
+  // Those are counted, not shown. A raw title the reader can't act on is
   // noise here and a writing bug at its source.
   const nextInfo = Array.isArray(nextMoves)
     ? { moves: nextMoves, unexplained: 0 }

package/lib/bench/engines.js

@@ -9,6 +9,9 @@ const ENGINE_NAMES = Object.freeze([
   'cursor',
   'claude',
   'atris-fast',
+  'agy',
+  'opencode',
+  'devin',
   'null',
   'solution',
 ]);
@@ -18,8 +21,13 @@ const ENGINE_BINS = Object.freeze({
   cursor: 'cursor-agent',
   claude: 'claude',
   'atris-fast': 'atris',
+  agy: 'agy',
+  opencode: 'opencode',
+  devin: 'devin',
 });
 
+const AGY_HEADLESS_NOTE = 'You are running headless with edit permission already granted. Apply changes directly and never ask for confirmation; finish the task fully, then report.';
+
 function normalizeEngineName(name) {
   const normalized = String(name || '').trim();
   if (!normalized) return '';
@@ -29,23 +37,30 @@ function normalizeEngineName(name) {
   return normalized;
 }
 
-function commandAvailable(command) {
+function commandAvailable(command, env = process.env) {
   const result = spawnSync('/bin/sh', ['-c', `command -v ${command}`], {
     encoding: 'utf8',
-    env: process.env,
+    env,
   });
   return result.status === 0 && Boolean(String(result.stdout || '').trim());
 }
 
 function spawnEngine(command, args, workspaceDir, timeoutMs, options = {}) {
+  // Two hermetic-workspace traps (verified live 2026-09-04): engines that
+  // read PWD from the environment (opencode) edited the real repo fixture
+  // instead of the temp workspace, and engines that read a piped stdin as
+  // the prompt (devin) exited 0 in 3s having done nothing. Point PWD at the
+  // workspace and close stdin unless the caller supplies input.
   const result = spawnSync(command, args, {
     cwd: workspaceDir,
     input: options.input,
+    stdio: options.input === undefined ? ['ignore', 'pipe', 'pipe'] : undefined,
     encoding: 'utf8',
     timeout: Number(timeoutMs || 300000),
     maxBuffer: Number(options.maxBuffer || 16 * 1024 * 1024),
     env: {
       ...process.env,
+      PWD: workspaceDir,
       ...(options.env || {}),
     },
   });
@@ -53,14 +68,15 @@ function spawnEngine(command, args, workspaceDir, timeoutMs, options = {}) {
     status: result.status === null ? 1 : result.status,
     stdout: result.stdout || '',
     stderr: result.error ? String(result.error.message || result.error) : (result.stderr || ''),
+    timedOut: Boolean(result.error && result.error.code === 'ETIMEDOUT'),
   };
 }
 
 function realEngineAdapter(name, bin, runArgs) {
   return {
     name,
-    available(workspaceDir) {
-      if (!commandAvailable(bin)) {
+    available(workspaceDir, env) {
+      if (!commandAvailable(bin, env)) {
         return { available: false, reason: `${bin} not found` };
       }
       if (name === 'atris-fast' && !fs.existsSync(path.join(workspaceDir, 'atris'))) {
@@ -68,8 +84,8 @@ function realEngineAdapter(name, bin, runArgs) {
       }
       return { available: true, reason: 'available' };
     },
-    run(promptText, workspaceDir, timeoutMs) {
-      return spawnEngine(bin, runArgs(promptText, workspaceDir), workspaceDir, timeoutMs);
+    run(promptText, workspaceDir, timeoutMs, env) {
+      return spawnEngine(bin, runArgs(promptText, workspaceDir), workspaceDir, timeoutMs, { env });
     },
   };
 }
@@ -95,14 +111,15 @@ function solutionEngineAdapter(solutionPath) {
       }
       return { available: true, reason: 'available' };
     },
-    run(_promptText, workspaceDir, timeoutMs) {
-      return spawnEngine('/bin/sh', [solutionPath], workspaceDir, timeoutMs);
+    run(_promptText, workspaceDir, timeoutMs, env) {
+      return spawnEngine('/bin/sh', [solutionPath], workspaceDir, timeoutMs, { env });
     },
   };
 }
 
 function getEngineAdapter(name, options = {}) {
   const normalized = normalizeEngineName(name);
+  const model = options.model ? String(options.model).trim() : '';
   if (normalized === 'null') return nullEngineAdapter();
   if (normalized === 'solution') return solutionEngineAdapter(options.solutionPath);
   if (normalized === 'codex') {
@@ -124,6 +141,40 @@ function getEngineAdapter(name, options = {}) {
       '--dangerously-skip-permissions',
     ]);
   }
+  if (normalized === 'agy') {
+    // --add-dir is mandatory: without it agy edits its own scratch folder.
+    // The headless note is mandatory too: with every auto-approve flag on,
+    // gemini still stops to ask "may I edit?" and exits 0 having changed
+    // nothing (verified on 3.7 and 3.8, 2026-09-04). One line fixes it.
+    return realEngineAdapter('agy', ENGINE_BINS.agy, (promptText, workspaceDir) => [
+      '--mode',
+      'accept-edits',
+      '--dangerously-skip-permissions',
+      '--add-dir',
+      workspaceDir,
+      ...(model ? ['--model', model] : []),
+      '-p',
+      `${AGY_HEADLESS_NOTE}\n\n${promptText}`,
+    ]);
+  }
+  if (normalized === 'opencode') {
+    return realEngineAdapter('opencode', ENGINE_BINS.opencode, (promptText) => [
+      'run',
+      '--auto',
+      ...(model ? ['-m', model] : []),
+      promptText,
+    ]);
+  }
+  if (normalized === 'devin') {
+    return realEngineAdapter('devin', ENGINE_BINS.devin, (promptText) => [
+      '-p',
+      '--permission-mode',
+      'dangerous',
+      ...(model ? ['--model', model] : []),
+      '--',
+      promptText,
+    ]);
+  }
   if (normalized === 'atris-fast') {
     return realEngineAdapter('atris-fast', ENGINE_BINS['atris-fast'], (promptText) => [
       'chat',

package/lib/bench/report.js

@@ -64,7 +64,7 @@ function buildBenchReport(options = {}) {
 
   const byEngine = new Map();
   for (const record of records) {
-    const engineName = record.engine || 'unknown';
+    const engineName = (record.engine || 'unknown') + (record.model ? `@${record.model}` : '');
     if (!byEngine.has(engineName)) byEngine.set(engineName, []);
     byEngine.get(engineName).push(record);
   }