atris 3.74.16 → 3.74.18

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/skills/README.md

@@ -26,6 +26,7 @@ cp -r atris/skills/[name] ~/.codex/skills/
 | Skill | Description | Policy |
 |-------|-------------|--------|
 | aeo | Content engineered to get cited by ChatGPT, Claude, and Gemini | - |
+| ambitious | Rewrite a task into the deeper version a top professional would do | - |
 | apps | View, manage, and trigger Atris apps | - |
 | atris | Workspace navigation, tasks, MAP.md, where-is-X questions | `policies/ANTISLOP.md` |
 | atris-feedback | Submit, list, resolve, close, or delete customer feedback | - |

package/atris/skills/ambitious/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: ambitious
+description: Turn a task into the deeper version a top professional would do, before any work starts. Answers four questions tied to the four values (ambition, agency, acceleration, accuracy), then rewrites the task. Deeper, not bigger. Triggers on be ambitious, ambitious, go deeper, deepen this, four As, 4A, what would a pro do.
+version: 1.4.0
+tags:
+  - method
+  - values
+  - prompting
+---
+
+# Be Ambitious
+
+Give it a task. It returns a deeper version of that task, not a bigger one.
+
+Adapted from a prompt shared by Felix Rieseberg (Anthropic), via Attention Heads. Each of its four questions maps to one of the four values in `atris.md`.
+
+## First, does it need deepening?
+
+Most asks do not. Pass the task through unchanged, with no questions answered, when it is quick and exact: a calculation, a formula, a conversion, a lookup, extracting items from pasted text, a short fix, or anything with one right answer the person already framed. Extra checks and caveats make those answers worse.
+
+Deepen only when the result depends on judgment: a plan, a decision, a design, code that will run on real data, advice where the obvious answer has a known trap, or prose someone will send. If unsure, pass it through.
+
+## The four questions
+
+Answer each one for the task's own field, in one to three concrete lines. Name real things: a named method, a named tool, a named source, a named check. Generic answers ("be thorough", "use best practices") fail the question.
+
+1. **Ambition. What would a top professional do here that the person is not asking for?** Picture the best practitioner in this exact field taking this exact job. Name the one or two moves they would make by default that the ask leaves out. Pick moves that make the same result better, not moves that add new deliverables.
+
+2. **Agency. What is the rawest material they would start from?** Not a summary, a dashboard, or someone's take. The source: the actual logs, the receipts, the customer's own words, the primary paper, the code path, the till tape. Say where it lives and how to get it. If it is not in reach right now, say what you will assume instead.
+
+3. **Acceleration. Which specific methods and tools would they use?** Name them. Prefer what already exists and is proven in this workspace or field over inventing something. The right named method is the shortcut.
+
+4. **Accuracy. What, other than you or the model, would show the result is right?** A test that fails before and passes after, a real run, a number that reconciles with a bank statement, a customer reply, a second reviewer on a different model. If nothing outside the model can check it, say so and name the closest proxy.
+
+## The rewrite
+
+Then rewrite the task as one prompt that folds in the answers. Rules:
+
+- **Deeper, not bigger.** Same deliverable, same audience, same size of ask. If the rewrite adds a second deliverable, cut it. The test: would the person recognize this as their task, done properly?
+- **Keep what they said.** Every constraint in the original survives the rewrite word for word in meaning.
+- **Name the check in the prompt.** The rewrite ends with how the result will be shown right (answer 4).
+- **Do the work now.** The deeper task never waits on material that is not in reach. It uses what is here, states its assumptions, and ends by naming the one piece of raw material that would sharpen it. Ask a question first only when the answer would change everything.
+- **Words for a person stay words.** When the deliverable is prose someone will send or say (a note, a toast, a post, an email, a bio, a job ad), the deliverable is only the words. This replaces the two rules above: the check and the missing material shape your choices silently and never appear as steps, sections, or notes. Write it complete, at the length asked. Leave a blank only for a fact only the person knows, like a name, and never invent one.
+- **Scale to the task.** A two-minute task gets a two-line rewrite. Do not turn a quick fix into a project.
+
+## Output shape
+
+For a pass-through:
+
+```
+deeper task:
+<the original task, word for word>
+```
+
+Otherwise:
+
+```
+ambition:     <answer 1>
+agency:       <answer 2>
+acceleration: <answer 3>
+accuracy:     <answer 4>
+
+deeper task:
+<the rewritten prompt>
+```
+
+Then do the deeper task, unless the person only asked for the rewrite.
+
+## When not to use it
+
+- The task is already a precise spec with a check (a failing test to make pass, a typo to fix). Do it.
+- The person asked for a quick answer or said "just". Respect it.
+- The deeper version needs money, sending, or publishing the original did not. Show the rewrite and ask first.

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/init.js

@@ -655,9 +655,7 @@ tools: []
 
 > Works with: Claude Code, Cursor, Codex, OpenClaw, Windsurf, and any AI coding agent.
 
-> New here? Read \`atris/FOR_AGENTS.md\` first.
 > If a repo you touch next has no \`atris/\` folder, run \`npx -y atris init\`.
-> Then read \`atris/atris.md\` and leave proof on disk.
 
 ## FIRST MESSAGE: Boot Sequence
 
@@ -675,20 +673,14 @@ ${agentsOpeningBlock}
 
 The person you work for does not know atris words and never has to learn them. Never tell them to run an atris command or learn a term.
 
-When their words match a move below, run it and report what happened in plain words.
-
-When unsure, run \`atris guide "<their words>"\` and follow its answer.
-
-After anything lands, offer one next move in plain words, never a command name.
+When their words ask for a move like "what should i do next", "keep going while i'm away", "remember this", or "our goal is x", run \`atris guide "<their words>"\`, then run the move it names and report what happened in plain words. When unsure, run \`atris guide "<their words>"\` and follow its answer. \`atris guide\` alone lists every move.
 
 Moves marked asks you first send messages, spend credits, or run for hours. Say in one sentence what would happen and wait for a yes before running them. Never add a skip flag like --yes on the person's behalf.
 
-Never end a reply with a command for the person to run. If a move needs a claim or an approval, do it for them and say what you did.
+Never end a reply with a command for the person to run. If a move needs a claim or an approval, do it for them and say what you did. After anything lands, offer one next move in plain words, never a command name.
 
 In a project with nothing on the list yet, speak first: three things you noticed about the codebase, one question, then start on the most useful one.
 
-${intentTable}
-
 ## The way of talking (every reply, no exceptions)
 
 Talk like a person. This governs every message you send the operator: boot, status, summaries, everything.
@@ -701,17 +693,42 @@ Talk like a person. This governs every message you send the operator: boot, stat
 - No em dashes anywhere; use a comma, colon, or period.
 - The test before sending: read it fried at 2am. If decoding takes work, rewrite it.
 
-copy these shapes:
+Canonical source: \`atris/atris.md\` \`## voice\`. This block is a copy for tools that only read \`AGENTS.md\`; if they differ, atris.md wins.
+
+## Read on demand
+
+Start on the job you were given. Open these only when the job needs them, not up front:
+
+| When | Read |
+|------|------|
+| You need to find where something lives | \`atris/MAP.md\` |
+| The work is bigger than a quick fix, or it involves tasks, missions, proof, or review | \`atris/atris.md\` (the protocol) |
+| You will create, claim, or hand off a task, report results, or run a mission | \`atris/AGENT_REFERENCE.md\` (task contract, reporting, missions, worktrees, rules) |
+| You are new to Atris | \`atris/FOR_AGENTS.md\` |
+| You are unsure how the person wants to be spoken to | \`atris/PERSONA.md\` |
+
+Do not write new operating doctrine here; add it to \`atris/atris.md\` and regenerate this adapter.`;
+
+  const agentReference = `# Agent reference
+
+The long form of \`AGENTS.md\`. Agents read this on demand, when the job involves tasks, reports, missions, or worktrees. The protocol itself is \`atris/atris.md\`.
+
+## Plain-English moves
+
+The same list \`atris guide\` prints. When the person's words match a move, run it and report what happened in plain words.
+
+${intentTable}
+
+## Reply shapes
+
 - **Status:** "The reply check is built. I am running the final checks now, so the result is not ready yet."
 - **Landing:** "Replies now get a plain-language check before they reach you. The checks passed, and the change is ready."
 - **Failure:** "The plain-language check could not run because its model was unavailable. Your reply still went through, so no work was blocked."
 
-Canonical source: \`atris/atris.md\` \`## voice\`. This block is a copy for tools that only read \`AGENTS.md\`; if they differ, atris.md wins.
-
 ## Core Files
 
-Atris is the source of truth. This file is only an adapter for tools that read
-\`AGENTS.md\`; do not turn it into a parallel brain. Durable policy, workflow,
+Atris is the source of truth. \`AGENTS.md\` and this file are only adapters for
+tools that read \`AGENTS.md\`; do not turn them into a parallel brain. Durable policy, workflow,
 task truth, proof, review, and backend/cloud sync all flow through Atris.
 
 | File | Purpose |
@@ -836,10 +853,7 @@ member -> mission start --verify -> status --status active -> one bounded step -
 - Don't leave stale tasks
 - Don't hand-edit TODO.md for active task ownership
 - Don't write verbose docs
-
----
-
-**Protocol:** See \`atris/atris.md\` for full spec.`;
+`;
 
   const voiceCard = voiceCardForRoot(process.cwd());
 
@@ -871,6 +885,12 @@ member -> mission start --verify -> status --status active -> one bounded step -
     fs.writeFileSync(agentsMdFile, agentInstructions);
     markReady('adapters', 'AGENTS.md', '✓ Created AGENTS.md (for Codex)');
   }
+  // The long form AGENTS.md points to; agents open it on demand.
+  const agentReferenceFile = path.join(targetDir, 'AGENT_REFERENCE.md');
+  if (!fs.existsSync(agentReferenceFile)) {
+    fs.writeFileSync(agentReferenceFile, agentReference);
+    markReady('workspace', 'AGENT_REFERENCE.md', '✓ Created AGENT_REFERENCE.md');
+  }
   const agentsVoiceResult = upsertAgentVoiceCard(agentsMdFile, voiceCard);
   if (agentsVoiceResult.action !== 'unchanged') {
     markReady('adapters', 'AGENTS.md voice card', '✓ Pinned the Atris voice card in AGENTS.md');

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
@@ -10056,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) {
@@ -12931,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.16",
+  "version": "3.74.18",
   "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",