atris 3.58.7 → 3.59.0

package/lib/runner-command.js

@@ -8,9 +8,13 @@
 // so autonomous runs are reproducible, while keeping explicit per-run/env knobs
 // first in precedence. Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
 // ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> pinned default.
-const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-4-8';
+const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-5-5';
 const DEFAULT_FABLE_RUNNER_MODEL = 'claude-fable-5';
 const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
+// Effort words a roster line may carry after the model. Each engine lists the
+// ones its CLI takes; an engine with no list takes none.
+const EFFORT_WORDS = Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']);
+const CLAUDE_EFFORTS = EFFORT_WORDS;
 
 // Canonical runner profiles. Each entry is the config an operator would pick
 // on purpose. Aliases (spelling variants of the same profile) resolve to the
@@ -30,16 +34,24 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     bin: 'claude',
     model: '',
     commandTemplate: '',
+    effortFlag: '--effort',
+    efforts: CLAUDE_EFFORTS,
   }),
+  // No -m or effort unless the roster pins one: codex then reads its own
+  // ~/.codex/config.toml, which is what the roster view reports.
   codex: Object.freeze({
     bin: 'codex',
     model: '',
-    commandTemplate: '{bin} exec {prompt}',
+    commandTemplate: '{bin} exec {pinnedModelFlag} {pinnedEffortFlag} {prompt}',
+    effortFlag: '-c model_reasoning_effort=',
+    efforts: Object.freeze(['low', 'medium', 'high', 'xhigh']),
   }),
+  // cursor-agent takes effort only inside a bracketed model name some models
+  // accept, so a roster effort on cursor is refused rather than guessed.
   cursor: Object.freeze({
     bin: 'cursor-agent',
     model: '',
-    commandTemplate: '{bin} --trust -p {prompt}',
+    commandTemplate: '{bin} --trust {pinnedModelFlag} -p {prompt}',
   }),
   // Fable is a distinct Claude Code model, not a friendly name for whatever
   // Claude model happens to be selected locally.
@@ -47,6 +59,8 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     bin: 'claude',
     model: DEFAULT_FABLE_RUNNER_MODEL,
     commandTemplate: '',
+    effortFlag: '--effort',
+    efforts: CLAUDE_EFFORTS,
   }),
   composer: Object.freeze({
     bin: 'ax',
@@ -57,29 +71,46 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     bin: 'claude',
     model: 'claude-haiku-4-5',
     commandTemplate: '',
+    effortFlag: '--effort',
+    efforts: CLAUDE_EFFORTS,
   }),
+  // Every engine with a model flag takes --model only when one is pinned (a
+  // roster pick or a mission model); otherwise it rides its own CLI default.
+  // {pinnedModelFlag} and {pinnedEffortFlag} render to nothing when unpinned.
+  // devin has no effort flag, so a roster effort on devin is refused.
   devin: Object.freeze({
     bin: 'devin',
     model: '',
-    commandTemplate: '{bin} -p -- {prompt}',
+    commandTemplate: '{bin} -p {pinnedModelFlag} -- {prompt}',
   }),
+  // 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: Object.freeze({
     bin: 'grok',
-    model: 'grok-4.6',
-    commandTemplate: '{bin} --always-approve -p {prompt}',
+    model: '',
+    commandTemplate: '{bin} --always-approve {pinnedModelFlag} {pinnedEffortFlag} -p {prompt}',
+    effortFlag: '--reasoning-effort',
+    efforts: Object.freeze(['low', 'medium', 'high']),
   }),
   agy: Object.freeze({
     bin: 'agy',
-    // gemini 3.8 flash is the 2026-09-04 bake-off pick beside opencode muse.
-    // --add-dir or agy edits its own scratch folder; the headless note or
-    // gemini stops to ask "may I edit?" and exits 0 having changed nothing.
-    model: 'gemini-3.8-flash-high',
-    commandTemplate: '{bin} --mode accept-edits --dangerously-skip-permissions --add-dir "$PWD" {modelFlag} -p "You are running headless with edit permission already granted. Apply changes directly and never ask for confirmation. "{prompt}',
+    // No hard pin: the agy CLI keeps its own session model, so an unpinned
+    // run rides that and a roster line names gemini 3.8 flash (the 2026-09-04
+    // bake-off pick) when it wants it. --add-dir or agy edits its own scratch
+    // folder; the headless note or gemini stops to ask "may I edit?" and
+    // exits 0 having changed nothing.
+    model: '',
+    commandTemplate: '{bin} --mode accept-edits --dangerously-skip-permissions --add-dir "$PWD" {pinnedModelFlag} {pinnedEffortFlag} -p "You are running headless with edit permission already granted. Apply changes directly and never ask for confirmation. "{prompt}',
+    effortFlag: '--effort',
+    efforts: Object.freeze(['low', 'medium', 'high']),
   }),
+  // opencode names models provider/model; --variant is its effort knob.
   opencode: Object.freeze({
     bin: 'opencode',
     model: '',
-    commandTemplate: '{bin} run {prompt}',
+    commandTemplate: '{bin} run {pinnedModelFlag} {pinnedEffortFlag} {prompt}',
+    effortFlag: '--variant',
+    efforts: Object.freeze(['low', 'medium', 'high', 'xhigh', 'max']),
   }),
   // Private engine: fully functional (routable, selectable, probeable) but
   // kept out of every operator-facing list. For engines an operator wants to
@@ -171,6 +202,15 @@ function resolveClaudeRunnerModel(mission) {
   return DEFAULT_CLAUDE_RUNNER_MODEL;
 }
 
+// The model chosen for this launch: an explicit model (a roster pick, a
+// mission model) or the profile's own pin. ATRIS_RUNNER_MODEL is left out on
+// purpose: it usually names a claude model, which devin or grok would reject.
+// '' means nothing is pinned, so the engine's CLI picks its own default.
+function resolvePinnedRunnerModel(mission) {
+  const explicit = mission && mission.model != null ? String(mission.model).trim() : '';
+  return explicit || runnerProfileValue('model');
+}
+
 function resolveClaudeRunnerBin() {
   const env = firstConfiguredEnv(['ATRIS_RUNNER_BIN']);
   if (env) return env;
@@ -206,8 +246,29 @@ function runnerAvailabilityFailureMessage(error) {
   return `${runnerBin} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`;
 }
 
-function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model }) {
+// The effort flag for the active profile, or '' when no effort is pinned.
+// Throws a plain sentence when the engine cannot take that effort, so a bad
+// pin never launches silently at the wrong effort.
+function runnerEffortFlag(effort) {
+  const word = String(effort || '').trim().toLowerCase();
+  if (!word) return '';
+  const profile = resolveRunnerProfile();
+  const flag = profile ? profile.effortFlag : RUNNER_PROFILE_DEFS.claude.effortFlag;
+  const allowed = profile ? profile.efforts : RUNNER_PROFILE_DEFS.claude.efforts;
+  const name = resolveRunnerProfileName() || 'claude';
+  if (!flag || !allowed || !allowed.includes(word)) throw new Error(`${name} cannot take the effort "${word}"`);
+  return flag.endsWith('=') ? `${flag}${word}` : `${flag} ${word}`;
+}
+
+function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model, pinnedModel = '', effort = '' }) {
   const allowedToolsFlag = allowedTools ? `--allowedTools ${shellWord(allowedTools)}` : '';
+  // The pinned flags take their leading space with them, so an unpinned
+  // launch reads exactly like the template without the placeholders.
+  template = template.replace(/\s*\{pinnedModelFlag\}/g, pinnedModel ? ` --model ${shellWord(pinnedModel)}` : '');
+  // Checked even when the template has no slot, so an engine that cannot
+  // take effort refuses instead of running at its default.
+  const effortFlag = runnerEffortFlag(effort);
+  template = template.replace(/\s*\{pinnedEffortFlag\}/g, effortFlag ? ` ${effortFlag}` : '');
   const promptFileWord = shellWord(promptFile);
   const values = {
     bin: shellWord(resolveClaudeRunnerBin()),
@@ -231,24 +292,42 @@ function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model
 // for GLM/OpenAI/other local runners. The old ATRIS_CLAUDE_* env vars remain
 // aliases for existing installs. allowedTools is optional: some call sites
 // (e.g. horizon proposal) run without a tool allowlist.
-function buildRunnerCommand({ promptFile, allowedTools, model } = {}) {
+function buildRunnerCommand({ promptFile, allowedTools, model, effort } = {}) {
   if (!promptFile) {
     throw new Error('buildRunnerCommand: promptFile is required');
   }
   const resolved = resolveClaudeRunnerModel({ model });
   const template = resolveClaudeRunnerCommandTemplate();
   if (template) {
-    return renderRunnerCommandTemplate(template, { promptFile, allowedTools, model: resolved });
+    return renderRunnerCommandTemplate(template, { promptFile, allowedTools, model: resolved, pinnedModel: resolvePinnedRunnerModel({ model }), effort });
   }
   const safePath = String(promptFile).replace(/'/g, "'\\''");
   let cmd = `${shellWord(resolveClaudeRunnerBin())} -p "$(cat '${safePath}')" --model ${shellWord(resolved)}`;
+  const effortFlag = runnerEffortFlag(effort);
+  if (effortFlag) cmd += ` ${effortFlag}`;
   if (allowedTools) {
     cmd += ` --allowedTools ${shellWord(allowedTools)}`;
   }
   return cmd;
 }
 
+// Whether this engine's launch can carry a pinned model, and which effort
+// words it takes. The roster checks both when it reads a line.
+function engineTakesModel(engineId) {
+  const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[engineId] || engineId];
+  if (!def) return false;
+  return !def.commandTemplate || def.commandTemplate.includes('{pinnedModelFlag}');
+}
+
+function engineEffortLevels(engineId) {
+  const def = RUNNER_PROFILE_DEFS[RUNNER_PROFILE_ALIASES[engineId] || engineId];
+  return def && def.efforts ? def.efforts : [];
+}
+
 module.exports = {
+  EFFORT_WORDS,
+  engineTakesModel,
+  engineEffortLevels,
   DEFAULT_CLAUDE_RUNNER_MODEL,
   DEFAULT_FABLE_RUNNER_MODEL,
   DEFAULT_CLAUDE_RUNNER_BIN,
@@ -259,6 +338,7 @@ module.exports = {
   HIDDEN_PROFILE_NAMES,
   resolveRunnerProfile,
   resolveClaudeRunnerModel,
+  resolvePinnedRunnerModel,
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerAvailabilityCommand,

package/lib/scorecard.js

@@ -245,14 +245,14 @@ function writeScorecard(atrisDir, data) {
 
   // Ensure scorecards.md exists
   if (!fs.existsSync(scorecardsPath)) {
-    const template = `# scorecards.md \u2014 Endgame Results\n\n> Append-only. One line per closed endgame. Records outcome metrics from the horizon.\n\n---\n\n`;
+    const template = `# scorecards.md: Endgame Results\n\n> Append-only. One line per closed endgame. Records outcome metrics from the horizon.\n\n---\n\n`;
     fs.writeFileSync(scorecardsPath, template, 'utf8');
   }
 
-  // Format: - **[date] slug**, shipped: X/Y, wall-clock: Nh, halt: Z%, reward: total, lessons: N
+  // Format: - **[date] slug** - shipped: X/Y - wall-clock: Nh - halt: Z% - reward: total - lessons: N
   const haltPercent = Math.round(haltRatio * 100);
   const wallClockStr = wallClockHours < 1 ? `${Math.round(wallClockHours * 60)}m` : `${wallClockHours.toFixed(1)}h`;
-  const line = `- **[${endDate}] ${slug}** \u2014 shipped: ${tasksShipped}/${tasksAttempted} \u2014 wall-clock: ${wallClockStr} \u2014 halt: ${haltPercent}% \u2014 reward: ${totalReward} \u2014 lessons: ${lessonsGenerated}\n`;
+  const line = `- **[${endDate}] ${slug}** - shipped: ${tasksShipped}/${tasksAttempted} - wall-clock: ${wallClockStr} - halt: ${haltPercent}% - reward: ${totalReward} - lessons: ${lessonsGenerated}\n`;
 
   // Append to file
   fs.appendFileSync(scorecardsPath, line, 'utf8');
@@ -302,7 +302,7 @@ function readScorecards(atrisDir) {
   const scorecards = [];
 
   for (const line of content.split('\n')) {
-    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*\u2014\s*shipped:\s*(\d+)\/(\d+)\s*\u2014\s*wall-clock:\s*(.+?)\s*\u2014\s*halt:\s*(\d+)%\s*\u2014\s*reward:\s*(-?\d+)\s*\u2014\s*lessons:\s*(\d+)$/);
+    const match = line.match(/^- \*\*\[(.+?)\]\s+(.+?)\*\*\s*[-\u2014]\s*shipped:\s*(\d+)\/(\d+)\s*[-\u2014]\s*wall-clock:\s*(.+?)\s*[-\u2014]\s*halt:\s*(\d+)%\s*[-\u2014]\s*reward:\s*(-?\d+)\s*[-\u2014]\s*lessons:\s*(\d+)$/);
     if (!match) continue;
 
     const [, endDate, slug, shipped, attempted, wallClockStr, haltPercent, reward, lessons] = match;

package/lib/self-drive.js

@@ -272,7 +272,15 @@ function handleMissionBlocker({ mission, stopReason, workspaceRoot, appendEvent
       agent: engine.id,
       task: `mission-blocker-${String(ref).toLowerCase()}`,
     });
-    deps.dispatchToEngine({ task, engine: engine.id, worktreePath: worktree.path, root: scopedRoot });
+    deps.dispatchToEngine({
+      task,
+      engine: engine.id,
+      worktreePath: worktree.path,
+      root: scopedRoot,
+      ...(engine.roster_model ? { model: engine.roster_model } : {}),
+      ...(engine.roster_effort ? { effort: engine.roster_effort } : {}),
+      ...(engine.roster_max_seconds ? { maxSeconds: engine.roster_max_seconds } : {}),
+    });
     projectTasks(deps.taskDb, db, scopedRoot);
     appendEvent?.('mission_blocker_dispatched', {
       task_id: ref,

package/lib/sleep-sync.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// Block the current thread for ms milliseconds without burning a core.
+// Atomics.wait parks the thread; a Date.now() loop keeps it at full CPU.
+function sleepSync(ms) {
+  const duration = Math.max(0, Number(ms) || 0);
+  if (!duration) return;
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, duration);
+}
+
+module.exports = { sleepSync };

package/lib/state-detection.js

@@ -271,6 +271,32 @@ function getTodayInboxItems(workspaceDir) {
 /**
  * Detect workspace state: fresh install, has inbox items, in-progress work, or blocked
  */
+// Blocked means a task whose status is failed: the DB has no separate
+// blocked status, doneTask logs a failed task as a "blocked" event, and the
+// board renders failed tasks under "## Blocked". Once this workspace has rows
+// in the task DB, the DB is the only source. The DB file is shared by every
+// workspace on the machine, so a workspace with no rows there falls back to
+// the Blocked section of its own TODO.md, never a word elsewhere in a title.
+function hasBlockedTasks(atrisDir, todoFile, legacyTaskContextFile) {
+  try {
+    const taskDb = require('./task-db');
+    if (fs.existsSync(taskDb.getDbPath())) {
+      const db = taskDb.open();
+      const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
+      if (taskDb.listTasks(db, { workspaceRoot, limit: 1 }).length) {
+        return taskDb.listTasks(db, { workspaceRoot, status: 'failed', limit: 1 }).length > 0;
+      }
+    }
+  } catch (e) {
+    if (process.env.ATRIS_DEBUG) console.error('[state-detection] db blocked read failed:', e.message);
+  }
+  const taskFilePath = fs.existsSync(todoFile)
+    ? todoFile
+    : (fs.existsSync(legacyTaskContextFile) ? legacyTaskContextFile : null);
+  if (!taskFilePath) return false;
+  return getTasksFromTodoSection(fs.readFileSync(taskFilePath, 'utf8'), 'Blocked').length > 0;
+}
+
 function detectWorkspaceState(workspaceDir) {
   const atrisDir = path.join(workspaceDir, 'atris');
   const featuresDir = path.join(atrisDir, 'features');
@@ -317,15 +343,8 @@ function detectWorkspaceState(workspaceDir) {
     }
   }
 
-  // Check for blocked tasks (prefer TODO.md, fallback to legacy TASK_CONTEXTS.md)
-  const taskFilePath = fs.existsSync(todoFile)
-    ? todoFile
-    : (fs.existsSync(legacyTaskContextFile) ? legacyTaskContextFile : null);
-  if (taskFilePath) {
-    const content = fs.readFileSync(taskFilePath, 'utf8');
-    if (content.includes('Risk Level: High') || /\bblocked\b/i.test(content)) {
-      return { state: 'blocked', reason: 'Tasks marked as blocked or high risk' };
-    }
+  if (hasBlockedTasks(atrisDir, todoFile, legacyTaskContextFile)) {
+    return { state: 'blocked', reason: 'Tasks marked as blocked' };
   }
 
   // Default: setup complete but no active work

package/lib/task-db.js

@@ -34,6 +34,7 @@ const { isDecisionTask } = require('./task-decision');
 const { parseVerifyCommand } = require('./auto-accept-certified');
 const { taskExplanation } = require('./task-explanation');
 const { treeHashFor } = require('./tree-hash');
+const { sleepSync } = require('./sleep-sync');
 
 const DEFAULT_DB_PATH = path.join(os.homedir(), '.atris', 'tasks.db');
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
@@ -2224,8 +2225,7 @@ function withBusyRetry(fn, attempts = 8) {
       const busy = /SQLITE_BUSY|database is locked/i.test(msg) || code === 'SQLITE_BUSY' || code === 5;
       if (!busy) throw e;
       // Sleep synchronously, node:sqlite is sync; matches the rest of the API
-      const end = Date.now() + delay + Math.floor(Math.random() * delay);
-      while (Date.now() < end) {} // tight loop is fine, delay is small
+      sleepSync(delay + Math.floor(Math.random() * delay));
       delay = Math.min(delay * 2, 500);
     }
   }
@@ -2234,6 +2234,7 @@ function withBusyRetry(fn, attempts = 8) {
 
 module.exports = {
   open,
+  withBusyRetry,
   close,
   getDbPath,
   workspaceRoot,

package/lib/todo-fallback.js

@@ -34,7 +34,7 @@ function cleanTaskTitle(text) {
   const withoutTags = raw.replace(/\s*\[[\w-]+\]/g, '').trim();
   const bold = withoutTags.match(/^\*\*(.+?)\*\*\s*(?:[\u2014-]\s*)?(.*)$/);
   if (!bold) return withoutTags;
-  return [bold[1], bold[2]].filter(Boolean).join(' \u2014 ').trim();
+  return [bold[1], bold[2]].filter(Boolean).join(' - ').replace(/\s*\u2014\s*/g, ' - ').trim();
 }
 
 function parseSection(content, sectionName) {

package/lib/wish-audit.js

@@ -407,9 +407,9 @@ function inferBudgetTier(text) {
   return tier || 'long';
 }
 
-function resolveRole(role, root) {
+function resolveRole(role, root, options = {}) {
   const resolver = engineRegistry.resolveRole || engineRegistry.resolve || engineRegistry.resolveEngineForRole;
-  return resolver(role, root);
+  return resolver(role, root, options);
 }
 
 // Route-time validator policy: the routing decision must not depend on which
@@ -430,12 +430,15 @@ function policyValidator(root, excludeId = '') {
   }
 }
 
-function resolveExecutor(root, engineOverride = '') {
+// A wish already sized quick (a small fix, tweak, or patch) asks the roster
+// for the owner's small build pick first; with none set, it routes as any
+// build. The router's own ranking is unchanged either way.
+function resolveExecutor(root, engineOverride = '', options = {}) {
   if (engineOverride) {
-    return engineRegistry.resolveEngineForRoleWithPreference('executor', root, engineOverride);
+    return engineRegistry.resolveEngineForRoleWithPreference('executor', root, engineOverride, options);
   }
   return {
-    engine: resolveRole('executor', root),
+    engine: resolveRole('executor', root, options),
     requested_engine: null,
     engine_fallback_reason: null,
   };
@@ -1034,7 +1037,8 @@ function auditWish(text, root = process.cwd(), options = {}) {
   let requestedEngine = null;
   let engineFallbackReason = null;
   try {
-    const resolved = resolveExecutor(root, engineOverride);
+    const small = inferBudgetTier(text) === 'quick' ? { job: engineRegistry.SMALL_BUILD_JOB } : {};
+    const resolved = resolveExecutor(root, engineOverride, small);
     executor = resolved.engine;
     requestedEngine = resolved.requested_engine;
     engineFallbackReason = resolved.engine_fallback_reason;

package/lib/wish-delegate.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { BACKEND_ROOT_HINT, resolveBackendRoot } = require('../utils/backend-root');
 const { getLogPath, ensureLogDirectory, createLogFile, addInboxIdea } = require('./file-ops');
 const { resolveFunctionalOwner } = require('./functional-owner');
 const { buildMissionRoom, writeMissionRoomReceipt } = require('./mission-room');
@@ -55,7 +56,6 @@ const {
 } = require('./wish-audit');
 
 const METRIC_OPS = { '>=': '--gte', '<=': '--lte', '==': '--eq', '>': '--gt', '<': '--lt' };
-const METRIC_VERIFY_ROOT = '/Users/keshavrao/arena/atrisos-backend';
 const DAY_MS = 24 * 60 * 60 * 1000;
 const HOUR_MS = 60 * 60 * 1000;
 const IMPLICIT_ANSWER_STALE_MS = HOUR_MS;
@@ -105,8 +105,11 @@ function parseMetricExpression(text) {
 
 // Wire to backend/scripts/metric_verify.py: exits 0 when the metric meets
 // target and prints a JSON line with value + proof_uri.
-function metricVerifierCommand(parsed) {
-  return `cd ${METRIC_VERIFY_ROOT} && venv/bin/python backend/scripts/metric_verify.py ${parsed.metric} ${parsed.flag} ${parsed.target}`;
+function metricVerifierCommand(parsed, workspace) {
+  const backend = resolveBackendRoot(workspace);
+  if (!backend) throw new Error(BACKEND_ROOT_HINT);
+  const quoted = `'${backend.replace(/'/g, `'\\''`)}'`;
+  return `cd ${quoted} && venv/bin/python backend/scripts/metric_verify.py ${parsed.metric} ${parsed.flag} ${parsed.target}`;
 }
 
 const MISSION_TERMINAL_STATUSES = new Set(['complete', 'stopped']);
@@ -489,7 +492,9 @@ function scorecardText(value) {
 }
 
 function readWishReviewRewardRows(root = process.cwd()) {
-  const file = path.resolve(root, '..', 'atrisos-backend', '.atris', 'state', 'scorecards.jsonl');
+  const backend = resolveBackendRoot(root);
+  if (!backend) return [];
+  const file = path.join(backend, '.atris', 'state', 'scorecards.jsonl');
   return readJsonLines(file).filter((row) => {
     const haystack = `${scorecardText(row.source)} ${scorecardText(row.feedback)}`;
     return /wish_review/i.test(haystack);
@@ -514,6 +519,7 @@ function reviewLine(review) {
 
 function printRewards(root = process.cwd()) {
   const reviews = readWishEvents(root).filter((event) => event && event.kind === 'review');
+  if (!resolveBackendRoot(root)) console.error(BACKEND_ROOT_HINT);
   const rewardRows = readWishReviewRewardRows(root);
   console.log(`reviews count: ${reviews.length}`);
   console.log(`avg score: ${averageReviewScore(reviews)}`);
@@ -749,7 +755,7 @@ function startWishDelegation(wish, audit, root, options = {}) {
   const suppliedVerifyHasCommand = !!(suppliedVerifyPlan && suppliedVerifyPlan.command);
   const userVerifyProvided = options.userVerifyProvided === true || options.verifyPlanExplicit === true;
   let verifyPlan = metricPlan
-    ? { command: metricVerifierCommand(metricPlan), outcome: `metric ${metricPlan.expression} is met`, status: 'metric' }
+    ? { command: metricVerifierCommand(metricPlan, root), outcome: `metric ${metricPlan.expression} is met`, status: 'metric' }
     : (suppliedVerifyPlan || deriveVerifyPlan(taskText));
   if (!metricPlan && frontendWish && designContext.auditCommand && !userVerifyProvided && !suppliedVerifyHasCommand && !(verifyPlan && verifyPlan.command)) {
     verifyPlan = designVerifyPlan(designContext);
@@ -757,6 +763,13 @@ function startWishDelegation(wish, audit, root, options = {}) {
   const missionVerifier = verifyPlan.command || resolveDefaultVerifier(root);
   const verifyWarning = verifierBudgetWarning(missionVerifier);
   const engine = wishDelegationEngine(audit, options);
+  // The build roster can pin a model for this engine; carry it onto the
+  // mission so the runner does not fall back to the engine default.
+  // Its effort and time cap ride along the same way.
+  const rosterPicked = Boolean(audit.executor && audit.executor.id === engine);
+  const rosterModel = audit.executor && audit.executor.id === engine && audit.executor.roster_model
+    ? audit.executor.roster_model
+    : '';
   const now = stampIso();
   const ownerResolution = resolveFunctionalOwner({
     requestedOwner: audit.executor.id,
@@ -893,6 +906,9 @@ function startWishDelegation(wish, audit, root, options = {}) {
           mission_room_receipt_path: writtenRoom.relativePath,
           mission_room_name: writtenRoom.room?.name || null,
           source: 'wish',
+          ...(rosterModel ? { model: rosterModel } : {}),
+          ...(rosterPicked && audit.executor.roster_effort ? { roster_effort: audit.executor.roster_effort } : {}),
+          ...(rosterPicked && audit.executor.roster_max_seconds ? { roster_max_seconds: audit.executor.roster_max_seconds } : {}),
           ...(verifyWarning ? { verifier_budget_warning: verifyWarning } : {}),
           ...(designBrief ? {
             design_brief_paths: designBrief.paths,
@@ -1529,6 +1545,10 @@ function runCapturedWish(text, root = process.cwd(), options = {}) {
   const asJson = !!options.asJson;
   const noMission = !!options.noMission;
   const builderMode = String(options.asMode || '').trim() === 'builder';
+  if (options.metric?.ok && !resolveBackendRoot(root)) {
+    console.error(BACKEND_ROOT_HINT);
+    return 2;
+  }
   let engineOverride = '';
   try {
     engineOverride = validateEngineOverride(options.engineOverride, root);
@@ -1617,6 +1637,10 @@ function runAgainWish(positionals, root = process.cwd(), options = {}) {
 function applyAnswer(wish, answer, root, options = {}) {
   const asJson = !!options.asJson;
   const noMission = !!options.noMission;
+  if (wish.metric && !resolveBackendRoot(root)) {
+    console.error(BACKEND_ROOT_HINT);
+    return 2;
+  }
   let engineOverride = '';
   try {
     engineOverride = validateEngineOverride(options.engineOverride, root);

package/mcp/atris-mcp/index.mjs

@@ -4,11 +4,9 @@
 // Auth resolves the same way as the CLI: ATRIS_API_KEY, then
 // the logged-in atris token, then ~/.atris/design-api-key.
 
-import { realpathSync } from 'node:fs';
+import { readFileSync, realpathSync } from 'node:fs';
+import { createInterface } from 'node:readline';
 import { fileURLToPath } from 'node:url';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import designApi from '../../lib/design-api.js';
 
 const { resolveDesignKey, designRequest, pollDesignJob, billingOf } = designApi;
@@ -141,34 +139,89 @@ export async function handleTool(name, args = {}, key) {
   return fail(`unknown tool: ${name}`);
 }
 
-export function createServer() {
-  const server = new Server(
-    { name: 'atris', version: '1.0.0' },
-    { capabilities: { tools: {} } },
-  );
+async function serveStdio() {
+  const { name, version } = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+  const knownVersions = new Set(['2024-11-05', '2025-03-26', '2025-06-18', '2025-11-25']);
+  const send = (message, onWritten) => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`, onWritten);
+  const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  const inFlight = new Set();
+  const pendingById = new Map();
 
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const key = resolveDesignKey();
-    if (!key) {
-      return fail('no api key found. set ATRIS_API_KEY or run: atris login (or save a key in ~/.atris/design-api-key)');
-    }
+  for await (const line of input) {
+    if (!line.trim()) continue;
+    let request;
     try {
-      return await handleTool(request.params.name, request.params.arguments || {}, key);
-    } catch (error) {
-      return fail(`design call failed: ${(error && error.message) || error}`);
+      request = JSON.parse(line);
+    } catch {
+      send({ id: null, error: { code: -32700, message: 'parse error' } });
+      continue;
+    }
+    if (!request || typeof request !== 'object' || Array.isArray(request)
+      || request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+      send({ id: request?.id ?? null, error: { code: -32600, message: 'invalid request' } });
+      continue;
     }
-  });
+    if (request.method === 'notifications/cancelled') {
+      const pending = pendingById.get(request.params?.requestId);
+      if (pending) pending.cancelled = true;
+      continue;
+    }
+    if (!Object.hasOwn(request, 'id')) continue;
 
-  return server;
+    const id = request.id;
+    let result;
+    if (request.method === 'initialize') {
+      result = {
+        protocolVersion: knownVersions.has(request.params?.protocolVersion)
+          ? request.params.protocolVersion : '2025-06-18',
+        capabilities: { tools: {} },
+        serverInfo: { name, version },
+      };
+    } else if (request.method === 'ping') {
+      result = {};
+    } else if (request.method === 'tools/list') {
+      result = { tools: TOOLS };
+    } else if (request.method === 'tools/call') {
+      const pending = { cancelled: false };
+      const work = (async () => {
+        try {
+          const key = resolveDesignKey();
+          result = key
+            ? await handleTool(request.params?.name, request.params?.arguments || {}, key)
+            : fail('no api key found. set ATRIS_API_KEY or run: atris login (or save a key in ~/.atris/design-api-key)');
+        } catch (error) {
+          result = fail(`design call failed: ${(error && error.message) || error}`);
+        }
+        if (!pending.cancelled) {
+          await new Promise((resolve, reject) => {
+            send({ id, result }, (error) => (error ? reject(error) : resolve()));
+          });
+        }
+      })();
+      inFlight.add(work);
+      pendingById.set(id, pending);
+      const done = () => {
+        inFlight.delete(work);
+        if (pendingById.get(id) === pending) pendingById.delete(id);
+      };
+      work.then(done, (error) => {
+        done();
+        process.stderr.write(`mcp response write failed: ${(error && error.message) || error}\n`);
+        process.exitCode = 1;
+      });
+      continue;
+    } else {
+      send({ id, error: { code: -32601, message: 'method not found' } });
+      continue;
+    }
+    send({ id, result });
+  }
+  await Promise.allSettled(inFlight);
 }
 
 // Auto-start only when run directly (`atris mcp`, `npx atris-mcp`,
 // node index.mjs); realpathSync resolves the npm bin symlink.
 const invokedPath = process.argv[1] ? realpathSync(process.argv[1]) : '';
 if (invokedPath && invokedPath === fileURLToPath(import.meta.url)) {
-  const server = createServer();
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  await serveStdio();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.58.7",
+  "version": "3.59.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
@@ -101,8 +101,5 @@
   "bugs": {
     "url": "https://github.com/atrislabs/atris/issues"
   },
-  "homepage": "https://github.com/atrislabs/atris#readme",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0"
-  }
+  "homepage": "https://github.com/atrislabs/atris#readme"
 }