atris 3.74.15 → 3.74.17

package/atris/atris.md

@@ -58,7 +58,7 @@ You can move fast. You do not get to move blindly.
 We have done a lot of great work, and because of it we will do even more.
 
 - **Acceleration.** Progress compounds. The early days are slow, then the curve bends and everything speeds up. Build on what is already done and settled; never redo it or re-ask it. Each landed piece makes the next one faster.
-- **Accuracy.** A win counts when the result is validated. A test that failed before and passes after, a gate, or a real run proves it. Small fast tasks can be proven by a check alone; good and big work also gets a second reviewer. Accuracy is the floor the other three stand on, so better tests make everything faster.
+- **Accuracy.** A win counts when the result is validated. A test that failed before and passes after, a gate, or a real run proves it. Not evidence: a test piped into `tail` or `grep` so its exit code is lost, a mock standing in for the real runtime, "should work", grading your own work, a test count with no repro that failed first, a summary of a file you did not open. Evidence: the real thing run end to end, a repro that failed and now passes, before and after numbers, the transcript or screenshot of the real run. Say done only next to that proof. Small fast tasks can be proven by a check alone; good and big work also gets a second reviewer. Accuracy is the floor the other three stand on, so better tests make everything faster.
 - **Ambition.** Always one more level. When the goal has a clear check, go for the bigger version or the great task. We are capable of it, and we always find ways to win.
 - **Agency.** Take action and own the outcome. Use every tool you have. When something is missing or broken, fix it the same turn instead of handing it back.
 

package/atris.md

@@ -58,7 +58,7 @@ You can move fast. You do not get to move blindly.
 We have done a lot of great work, and because of it we will do even more.
 
 - **Acceleration.** Progress compounds. The early days are slow, then the curve bends and everything speeds up. Build on what is already done and settled; never redo it or re-ask it. Each landed piece makes the next one faster.
-- **Accuracy.** A win counts when the result is validated. A test that failed before and passes after, a gate, or a real run proves it. Small fast tasks can be proven by a check alone; good and big work also gets a second reviewer. Accuracy is the floor the other three stand on, so better tests make everything faster.
+- **Accuracy.** A win counts when the result is validated. A test that failed before and passes after, a gate, or a real run proves it. Not evidence: a test piped into `tail` or `grep` so its exit code is lost, a mock standing in for the real runtime, "should work", grading your own work, a test count with no repro that failed first, a summary of a file you did not open. Evidence: the real thing run end to end, a repro that failed and now passes, before and after numbers, the transcript or screenshot of the real run. Say done only next to that proof. Small fast tasks can be proven by a check alone; good and big work also gets a second reviewer. Accuracy is the floor the other three stand on, so better tests make everything faster.
 - **Ambition.** Always one more level. When the goal has a clear check, go for the bigger version or the great task. We are capable of it, and we always find ways to win.
 - **Agency.** Take action and own the outcome. Use every tool you have. When something is missing or broken, fix it the same turn instead of handing it back.
 

package/commands/member.js

@@ -981,9 +981,39 @@ function inferMemberRunVerifier(missionText, args = [], cwd = process.cwd()) {
   // chose that check; it is not a silent broad-suite default.
   const npmMatch = text.match(/\bnpm\s+(run\s+)?test(?![\w:-]|\.\w)/i);
   if (npmMatch && projectHasTestScript(cwd)) return npmMatch[1] ? 'npm run test' : 'npm test';
+  // A named test file in a project that runs node's own test runner: check
+  // just that file, since other files may fail on purpose ("legacy.js is out
+  // of scope"). Member lab: these jobs fell back to a whitespace check.
+  // Only sentences that ask for the work count; "x is out of scope" or "do not
+  // run the failing tests" must not pick a check.
+  const asks = text.split(/[;,\n]+|\.(?=\s|$)|\s(?:and|but)\s/i).filter((part) => part.trim()
+    && !/\b(out\s+of\s+scope|do\s+not|don't|never|without|skip|ignore|leave|except|known\s+bug|reference)\b/i.test(part)).join('. ');
+  const testScript = projectTestScript(cwd);
+  // The project runs node's test runner itself, not as part of another command.
+  if (/^\s*node\s+--test\b/.test(testScript) && !/&&|\|\||[;|]/.test(testScript)) {
+    const root = path.resolve(cwd);
+    const named = (asks.match(/[\w./-]+\.[cm]?js\b/g) || [])
+      .filter((file) => /(^|\/)(tests?|checks?|specs?|__tests__)\/|\.(test|spec)\.[cm]?js$/.test(file))
+      .filter((file) => !path.isAbsolute(file) && path.resolve(root, file).startsWith(`${root}${path.sep}`))
+      .find((file) => fs.existsSync(path.join(root, file)));
+    if (named) return `node --test ${named}`;
+  }
+  // "fix the failing tests" names the project's tests as the target.
+  if (testScript && /\b(fail(ing|ed)?\s+(\w+\s+){0,3}tests?|tests?\s+(pass|green)|fix\s+the\s+(\w+\s+){0,2}tests?)\b/i.test(asks)) {
+    return 'npm test';
+  }
   return '';
 }
 
+function projectTestScript(cwd) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    return String(pkg?.scripts?.test || '');
+  } catch {
+    return '';
+  }
+}
+
 function projectHasTestScript(cwd) {
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
@@ -1069,6 +1099,16 @@ function startMemberRunMission(name, missionText, args = []) {
 // second engine only reran the same commands and cost about a minute a run
 // (member lab 2026-10-24), so it stays for runs whose check is not a test
 // runner (whitespace, syntax, or file-exists checks). --no-referee skips it; an explicit --referee is kept.
+// 'checked' when the run passed, 'unchecked' when the only thing missing is a
+// reviewer verdict (timed out or could not start), '' otherwise.
+function memberRunSaveDecision({ started, ok, verdict } = {}) {
+  if (!started) return '';
+  const v = verdict || {};
+  if (v.passed === true) return ok ? 'checked' : '';
+  const reviewerGone = v.referee?.mode === 'engine-unavailable' || v.mode === 'engine-unavailable';
+  return reviewerGone && (v.status === undefined || v.status === 0) ? 'unchecked' : '';
+}
+
 function memberRunHasRealCheck(verifier) {
   const command = String(verifier || '').trim();
   // A plain test runner only: chaining (|| true, ; , &&, pipes, subshells) or a
@@ -1468,13 +1508,22 @@ function memberRunWith(name, args, { quiet = false, closeTaskIds = [] } = {}) {
   }
   // Passed but never committed: save the loose work on the member's branch so
   // the branch holds it. Only in the member's own side checkout, never the main one.
+  // A reviewer that timed out or could not start gave no verdict; the work is
+  // unchecked, not rejected, so save it too (member lab: a correct answer was
+  // lost when the reviewer hit its time limit on a busy machine). Landing still
+  // needs a real pass.
   const worktreePath = finalMission.worktree?.path || mission.worktree?.path || '';
-  if (ok && started && worktreePath && finalMission.verifier_result?.passed === true) {
+  const saveDecision = memberRunSaveDecision({ started, ok, verdict: finalMission.verifier_result });
+  const reviewerUnavailable = saveDecision === 'unchecked';
+  if (worktreePath && saveDecision) {
     result.saved_work = require('../lib/member-save-work').saveLeftoverMemberWork({
       worktreePath, member: name, objective: finalMission.objective || mission.objective,
     });
+    if (reviewerUnavailable) result.saved_work.unchecked = true;
     if (result.saved_work.saved && !asJson && !quiet) {
-      console.log(`saved ${result.saved_work.files.length} file(s) ${name} left unsaved onto its branch`);
+      console.log(reviewerUnavailable
+        ? `saved ${result.saved_work.files.length} file(s) onto ${name}'s branch, not checked yet: the reviewer timed out or could not start`
+        : `saved ${result.saved_work.files.length} file(s) ${name} left unsaved onto its branch`);
     }
   }
   // A finished ignited run whose check passed hands its branch to GitHub
@@ -12140,6 +12189,7 @@ module.exports = {
   wakeBootLines,
   buildMemberRunStartArgs,
   inferMemberRunVerifier,
+  memberRunSaveDecision,
   buildMemberSubagentShell,
   pickMemberForIdea,
   appendMemberGoalLog,

package/commands/mission.js

@@ -6971,10 +6971,21 @@ function tickTouchedCheckDefinition(verifier, before, root = process.cwd()) {
   // Runners that find tests by name (node --test, jest, pytest, go test) never
   // list them, so any changed file shaped like a test counts as well.
   const testShaped = /(^|\/)(tests?|__tests__|specs?|checks?)\/|\.(test|spec)\.[cm]?[jt]sx?$|_test\.(go|py)$|(^|\/)test_[^/]*\.py$|(^|\/)conftest\.py$/i;
+  // Whole paths only: order.js is not named by `node --test checks/order.js`.
+  // Shell punctuation ends a word, and $PWD or this folder's own path is cut off.
+  const here = [path.resolve(root), (() => { try { return fs.realpathSync(root); } catch { return ''; } })()].filter(Boolean);
+  const named = checkText.split(/[\s'"`=;&|<>()]+/)
+    .map((word) => {
+      let clean = word.replace(/^\$\{?PWD\}?\//, '');
+      const inside = here.find((dir) => clean.startsWith(`${dir}/`));
+      if (inside) clean = clean.slice(inside.length + 1);
+      return clean.replace(/^(\.\/)+/, '');
+    })
+    .filter(Boolean);
   return changed.some((file) => path.basename(file) === 'package.json'
     || testShaped.test(file)
-    || checkText.includes(file)
-    || (path.dirname(file) !== '.' && checkText.includes(`${path.dirname(file)}/`)));
+    || named.includes(file)
+    || (path.dirname(file) !== '.' && named.some((word) => word.startsWith(`${path.dirname(file)}/`))));
 }
 
 // The worker's `learned:` line from its receipt, so the lesson reaches the
@@ -9997,6 +10008,9 @@ function buildEngineVerifyPrompt(mission, tickIndex, doneLooksLike = '', { timeo
       `Split that line into each separate thing it promises and check every one. List each part as met or missing.`,
       `Work that does only some of the parts is not done. If any part is missing, end with 'VERDICT: FAIL; missing: <that part>'.`,
     ] : []),
+    // Member lab: reviewers spent about half their time on the workspace boot
+    // (atris atris.md, MAP, PERSONA, skills) before reading the change.
+    `Skip any workspace boot or start-of-session routine the folder's instructions ask for: do not run \`atris atris.md\` and do not read MAP.md, PERSONA.md, FOR_AGENTS.md, or skill files. Start with \`git diff\` and the changed files.`,
     `Read the diff this tick produced. Do not edit files and do not start another work slice.`,
     `ACTUALLY RUN the changed surface on this computer using real commands and real exit codes.`,
     `Paste the commands and their real output. Do not accept a receipt claim or static inspection as execution proof.`,
@@ -10053,31 +10067,87 @@ function pickCrossEngineVerifier(mission, cwd = process.cwd(), preferredEngine =
   return workerEngine === 'codex' ? 'claude' : 'codex';
 }
 
+// Engine health lives in the main checkout, so a reviewer benched from one
+// member's side folder stays benched for the next member's review.
+function engineHealthRoot(cwd) {
+  const common = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd, encoding: 'utf8' });
+  const dir = common.status === 0 ? String(common.stdout || '').trim() : '';
+  return dir && path.basename(dir) === '.git' ? path.dirname(dir) : cwd;
+}
+
+// Every spelling and version of one model family counts as the same model,
+// with or without the long-context tag. Unknown counts as same.
+function reviewerMayBeSameModel(a, b) {
+  const { CLAUDE_MODEL_ALIASES, CLAUDE_LONG_CONTEXT } = require('../lib/model-names');
+  const key = (model) => {
+    const name = String(model || '').toLowerCase().replace(CLAUDE_LONG_CONTEXT, '').replace(/^claude-/, '').trim();
+    return CLAUDE_MODEL_ALIASES.find((family) => name.split(/[^a-z]+/).includes(family)) || name;
+  };
+  const left = key(a);
+  const right = key(b);
+  return !left || !right || left.includes(right) || right.includes(left);
+}
+
+// Who reviews, in order. The usual reviewer first; then the roster's next
+// review worker, when it is not the builder grading itself: on the builder's
+// engine it must be a different model. A benched reviewer is skipped while
+// its backup can run. A named reviewer is never swapped.
+function engineVerifierLineup(mission, cwd, preferredEngine = '', options = {}) {
+  const primary = pickCrossEngineVerifier(mission, cwd, preferredEngine);
+  const lineup = [{ engine: primary, model: '' }];
+  if (preferredEngine || mission?.referee_engine) return lineup;
+  const root = options.healthRoot || engineHealthRoot(cwd);
+  try {
+    const registry = require('../lib/engine-registry');
+    const workerEngine = canonicalEngineName(mission?.runner) || 'claude';
+    const workerModel = resolveMissionTickRunnerModel(mission);
+    const team = registry.resolveEngineForRoleRanked('validator', root, { job: 'review', quiet: true }).team || [];
+    const backup = team.find((engine) => engine && engine.id !== primary
+      && !(engine.id === workerEngine && reviewerMayBeSameModel(engine.roster_model, workerModel)));
+    if (!backup) return lineup;
+    lineup.push({ engine: backup.id, model: backup.roster_model || '' });
+    const saved = registry.readEngineRegistry(root, { persist: false }).engines.find((engine) => engine.id === primary);
+    if (saved && !registry.engineReadyAt(saved)) lineup.shift();
+  } catch {}
+  return lineup;
+}
+
 async function runEngineVerifier(mission, options = {}) {
   const cwd = options.cwd || process.cwd();
-  const engine = pickCrossEngineVerifier(mission, cwd, options.refereeEngine);
-  const verifyMission = { ...mission, runner: engine, runner_kind: 'engine', model: '' };
-  const restoreRunnerProfile = applyMissionRunnerProfile(engine);
-  let engineResult;
-  try {
-    engineResult = await spawnClaudeTick(verifyMission, {
-      sessionMode: 'set',
-      sessionId: crypto.randomUUID(),
-      cwd,
-      signal: options.signal,
-      timeoutMs: ENGINE_VERIFY_TIMEOUT_MS,
-      prompt: buildEngineVerifyPrompt(mission, options.tickIndex || 1, missionDoneLooksLike(mission, cwd), {
+  const healthRoot = engineHealthRoot(cwd);
+  const lineup = engineVerifierLineup(mission, cwd, options.refereeEngine, { healthRoot });
+  let verdict = null;
+  for (const { engine, model } of lineup) {
+    const verifyMission = { ...mission, runner: engine, runner_kind: 'engine', model };
+    const restoreRunnerProfile = applyMissionRunnerProfile(engine);
+    let engineResult;
+    try {
+      engineResult = await spawnClaudeTick(verifyMission, {
+        sessionMode: 'set',
+        sessionId: crypto.randomUUID(),
+        cwd,
+        signal: options.signal,
         timeoutMs: ENGINE_VERIFY_TIMEOUT_MS,
-        checkPassed: options.checkPassed || '',
-      }),
-      model: resolveMissionTickRunnerModel(verifyMission),
-    });
-  } catch (error) {
-    engineResult = { ok: false, error: error.message };
-  } finally {
-    restoreRunnerProfile();
+        prompt: buildEngineVerifyPrompt(mission, options.tickIndex || 1, missionDoneLooksLike(mission, cwd), {
+          timeoutMs: ENGINE_VERIFY_TIMEOUT_MS,
+          checkPassed: options.checkPassed || '',
+        }),
+        model: resolveMissionTickRunnerModel(verifyMission),
+      });
+    } catch (error) {
+      engineResult = { ok: false, error: error.message };
+    } finally {
+      restoreRunnerProfile();
+    }
+    verdict = engineVerifierResultFromRun(engineResult, engine);
+    if (verdict.mode !== 'engine-unavailable' || engineResult?.aborted) return verdict;
+    // Member lab 10/26: codex hung on every review, and each job waited out
+    // the full five minutes. Bench it so the next review starts on the backup.
+    if (engineResult?.timedOut) {
+      try { setEngineHealth(engine, 'cooling', healthRoot); } catch {}
+    }
   }
-  return engineVerifierResultFromRun(engineResult, engine);
+  return verdict;
 }
 
 function stripClaudeReceiptLine(line) {
@@ -12928,6 +12998,7 @@ function missionCommand(args) {
 module.exports = {
   receiptLearnedLine,
   tickTouchedCheckDefinition,
+  engineVerifierLineup,
   claudeRunnerMcpArgs,
   crystallizeMemberSkillLesson,
   listSiblingWorkspaceMissionHints,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.74.15",
+  "version": "3.74.17",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "mcpName": "io.github.atrislabs/atris",
   "main": "bin/atris.js",